diff --git a/ghcjs-dom-jsffi.cabal b/ghcjs-dom-jsffi.cabal
--- a/ghcjs-dom-jsffi.cabal
+++ b/ghcjs-dom-jsffi.cabal
@@ -1,5 +1,5 @@
 name: ghcjs-dom-jsffi
-version: 0.4.1.1
+version: 0.5.0.0
 cabal-version: >=1.24
 build-type: Simple
 license: MIT
diff --git a/src/GHCJS/DOM/EventM.hs b/src/GHCJS/DOM/EventM.hs
--- a/src/GHCJS/DOM/EventM.hs
+++ b/src/GHCJS/DOM/EventM.hs
@@ -75,6 +75,8 @@
 import           GHCJS.DOM.EventTargetClosures
 import           Data.Word (Word)
 import           Data.Foldable (forM_)
+import           Data.Traversable (mapM)
+import           Data.Coerce (coerce)
 
 type EventM t e = ReaderT e IO
 
@@ -121,7 +123,7 @@
 eventTarget = event >>= Event.getTarget
 
 target :: (IsEvent e, IsGObject t) => EventM t e (Maybe t)
-target = (fmap (unsafeCastGObject . toGObject)) <$> eventTarget
+target = eventTarget >>= mapM (liftJSM . fromJSValUnchecked . coerce)
 
 eventCurrentTarget :: IsEvent e => EventM t e (Maybe EventTarget)
 eventCurrentTarget = event >>= Event.getCurrentTarget
diff --git a/src/GHCJS/DOM/EventTargetClosures.hs b/src/GHCJS/DOM/EventTargetClosures.hs
--- a/src/GHCJS/DOM/EventTargetClosures.hs
+++ b/src/GHCJS/DOM/EventTargetClosures.hs
@@ -3,6 +3,7 @@
        (EventName(..), SaferEventListener(..), unsafeEventName, eventListenerNew, eventListenerNewSync, eventListenerNewAsync, eventListenerRelease) where
 
 import Control.Applicative ((<$>))
+import Control.Monad ((>=>))
 import GHCJS.Types
 import GHCJS.Foreign.Callback.Internal
 import GHCJS.Foreign.Callback
@@ -25,13 +26,13 @@
 unsafeEventName = EventName
 
 eventListenerNew :: IsEvent event => (event -> IO ()) -> IO EventListener
-eventListenerNew callback = (EventListener . jsval) <$> syncCallback1 ContinueAsync (callback . unsafeCastGObject . GObject)
+eventListenerNew callback = (EventListener . jsval) <$> syncCallback1 ContinueAsync (fromJSValUnchecked >=> callback)
 
 eventListenerNewSync :: IsEvent event => (event -> IO ()) -> IO EventListener
-eventListenerNewSync callback = (EventListener . jsval) <$> syncCallback1 ThrowWouldBlock (callback . unsafeCastGObject . GObject)
+eventListenerNewSync callback = (EventListener . jsval) <$> syncCallback1 ThrowWouldBlock (fromJSValUnchecked >=> callback)
 
 eventListenerNewAsync :: IsEvent event => (event -> IO ()) -> IO EventListener
-eventListenerNewAsync callback = (EventListener . jsval) <$> asyncCallback1 (callback . unsafeCastGObject . GObject)
+eventListenerNewAsync callback = (EventListener . jsval) <$> asyncCallback1 (fromJSValUnchecked >=> callback)
 
 eventListenerRelease :: EventListener -> IO ()
 eventListenerRelease (EventListener ref) = releaseCallback (Callback ref)
diff --git a/src/GHCJS/DOM/JSFFI/Generated/ANGLEInstancedArrays.hs b/src/GHCJS/DOM/JSFFI/Generated/ANGLEInstancedArrays.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/ANGLEInstancedArrays.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/ANGLEInstancedArrays.hs
@@ -1,12 +1,18 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.ANGLEInstancedArrays
        (js_drawArraysInstancedANGLE, drawArraysInstancedANGLE,
         js_drawElementsInstancedANGLE, drawElementsInstancedANGLE,
         js_vertexAttribDivisorANGLE, vertexAttribDivisorANGLE,
-        pattern VERTEX_ATTRIB_ARRAY_DIVISOR_ANGLE, ANGLEInstancedArrays,
-        castToANGLEInstancedArrays, gTypeANGLEInstancedArrays)
+        pattern VERTEX_ATTRIB_ARRAY_DIVISOR_ANGLE,
+        ANGLEInstancedArrays(..), gTypeANGLEInstancedArrays)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -22,6 +28,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe
         "$1[\"drawArraysInstancedANGLE\"]($2,\n$3, $4, $5)"
diff --git a/src/GHCJS/DOM/JSFFI/Generated/AbstractView.hs b/src/GHCJS/DOM/JSFFI/Generated/AbstractView.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/AbstractView.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/AbstractView.hs
@@ -1,10 +1,17 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.AbstractView
-       (js_getDocument, getDocument, getDocumentUnchecked,
-        js_getStyleMedia, getStyleMedia, getStyleMediaUnchecked,
-        AbstractView, castToAbstractView, gTypeAbstractView)
+       (js_getDocument, getDocument, getDocumentUnsafe,
+        getDocumentUnchecked, js_getStyleMedia, getStyleMedia,
+        getStyleMediaUnsafe, getStyleMediaUnchecked, AbstractView(..),
+        gTypeAbstractView)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -20,6 +27,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"document\"]" js_getDocument
         :: AbstractView -> IO (Nullable Document)
@@ -30,6 +47,14 @@
   = liftIO (nullableToMaybe <$> (js_getDocument (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/AbstractView.document Mozilla AbstractView.document documentation> 
+getDocumentUnsafe ::
+                  (MonadIO m, HasCallStack) => AbstractView -> m Document
+getDocumentUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getDocument (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/AbstractView.document Mozilla AbstractView.document documentation> 
 getDocumentUnchecked :: (MonadIO m) => AbstractView -> m Document
 getDocumentUnchecked self
   = liftIO (fromJust . nullableToMaybe <$> (js_getDocument (self)))
@@ -42,6 +67,14 @@
               (MonadIO m) => AbstractView -> m (Maybe StyleMedia)
 getStyleMedia self
   = liftIO (nullableToMaybe <$> (js_getStyleMedia (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/AbstractView.styleMedia Mozilla AbstractView.styleMedia documentation> 
+getStyleMediaUnsafe ::
+                    (MonadIO m, HasCallStack) => AbstractView -> m StyleMedia
+getStyleMediaUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getStyleMedia (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/AbstractView.styleMedia Mozilla AbstractView.styleMedia documentation> 
 getStyleMediaUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/AbstractWorker.hs b/src/GHCJS/DOM/JSFFI/Generated/AbstractWorker.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/AbstractWorker.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/AbstractWorker.hs
@@ -1,8 +1,13 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.AbstractWorker
-       (error, AbstractWorker, castToAbstractWorker, gTypeAbstractWorker)
-       where
+       (error, AbstractWorker(..), gTypeAbstractWorker) where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -18,6 +23,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/AbstractWorker.onerror Mozilla AbstractWorker.onerror documentation> 
 error :: EventName AbstractWorker UIEvent
diff --git a/src/GHCJS/DOM/JSFFI/Generated/AllAudioCapabilities.hs b/src/GHCJS/DOM/JSFFI/Generated/AllAudioCapabilities.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/AllAudioCapabilities.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/AllAudioCapabilities.hs
@@ -1,10 +1,16 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.AllAudioCapabilities
        (js_getSourceId, getSourceId, js_getVolume, getVolume,
-        getVolumeUnchecked, AllAudioCapabilities,
-        castToAllAudioCapabilities, gTypeAllAudioCapabilities)
+        getVolumeUnsafe, getVolumeUnchecked, AllAudioCapabilities(..),
+        gTypeAllAudioCapabilities)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -20,6 +26,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"sourceId\"]" js_getSourceId
         :: AllAudioCapabilities -> IO JSVal
@@ -38,6 +54,15 @@
 getVolume ::
           (MonadIO m) => AllAudioCapabilities -> m (Maybe CapabilityRange)
 getVolume self = liftIO (nullableToMaybe <$> (js_getVolume (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/AllAudioCapabilities.volume Mozilla AllAudioCapabilities.volume documentation> 
+getVolumeUnsafe ::
+                (MonadIO m, HasCallStack) =>
+                  AllAudioCapabilities -> m CapabilityRange
+getVolumeUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getVolume (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/AllAudioCapabilities.volume Mozilla AllAudioCapabilities.volume documentation> 
 getVolumeUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/AllVideoCapabilities.hs b/src/GHCJS/DOM/JSFFI/Generated/AllVideoCapabilities.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/AllVideoCapabilities.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/AllVideoCapabilities.hs
@@ -1,14 +1,20 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.AllVideoCapabilities
        (js_getSourceType, getSourceType, js_getSourceId, getSourceId,
-        js_getWidth, getWidth, getWidthUnchecked, js_getHeight, getHeight,
-        getHeightUnchecked, js_getFrameRate, getFrameRate,
+        js_getWidth, getWidth, getWidthUnsafe, getWidthUnchecked,
+        js_getHeight, getHeight, getHeightUnsafe, getHeightUnchecked,
+        js_getFrameRate, getFrameRate, getFrameRateUnsafe,
         getFrameRateUnchecked, js_getAspectRatio, getAspectRatio,
-        getAspectRatioUnchecked, js_getFacingMode, getFacingMode,
-        AllVideoCapabilities, castToAllVideoCapabilities,
-        gTypeAllVideoCapabilities)
+        getAspectRatioUnsafe, getAspectRatioUnchecked, js_getFacingMode,
+        getFacingMode, AllVideoCapabilities(..), gTypeAllVideoCapabilities)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -24,6 +30,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"sourceType\"]"
         js_getSourceType :: AllVideoCapabilities -> IO JSVal
@@ -54,6 +70,15 @@
 getWidth self = liftIO (nullableToMaybe <$> (js_getWidth (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/AllVideoCapabilities.width Mozilla AllVideoCapabilities.width documentation> 
+getWidthUnsafe ::
+               (MonadIO m, HasCallStack) =>
+                 AllVideoCapabilities -> m CapabilityRange
+getWidthUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getWidth (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/AllVideoCapabilities.width Mozilla AllVideoCapabilities.width documentation> 
 getWidthUnchecked ::
                   (MonadIO m) => AllVideoCapabilities -> m CapabilityRange
 getWidthUnchecked self
@@ -68,6 +93,15 @@
 getHeight self = liftIO (nullableToMaybe <$> (js_getHeight (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/AllVideoCapabilities.height Mozilla AllVideoCapabilities.height documentation> 
+getHeightUnsafe ::
+                (MonadIO m, HasCallStack) =>
+                  AllVideoCapabilities -> m CapabilityRange
+getHeightUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getHeight (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/AllVideoCapabilities.height Mozilla AllVideoCapabilities.height documentation> 
 getHeightUnchecked ::
                    (MonadIO m) => AllVideoCapabilities -> m CapabilityRange
 getHeightUnchecked self
@@ -84,6 +118,15 @@
   = liftIO (nullableToMaybe <$> (js_getFrameRate (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/AllVideoCapabilities.frameRate Mozilla AllVideoCapabilities.frameRate documentation> 
+getFrameRateUnsafe ::
+                   (MonadIO m, HasCallStack) =>
+                     AllVideoCapabilities -> m CapabilityRange
+getFrameRateUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getFrameRate (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/AllVideoCapabilities.frameRate Mozilla AllVideoCapabilities.frameRate documentation> 
 getFrameRateUnchecked ::
                       (MonadIO m) => AllVideoCapabilities -> m CapabilityRange
 getFrameRateUnchecked self
@@ -98,6 +141,15 @@
                (MonadIO m) => AllVideoCapabilities -> m (Maybe CapabilityRange)
 getAspectRatio self
   = liftIO (nullableToMaybe <$> (js_getAspectRatio (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/AllVideoCapabilities.aspectRatio Mozilla AllVideoCapabilities.aspectRatio documentation> 
+getAspectRatioUnsafe ::
+                     (MonadIO m, HasCallStack) =>
+                       AllVideoCapabilities -> m CapabilityRange
+getAspectRatioUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getAspectRatio (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/AllVideoCapabilities.aspectRatio Mozilla AllVideoCapabilities.aspectRatio documentation> 
 getAspectRatioUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/AnalyserNode.hs b/src/GHCJS/DOM/JSFFI/Generated/AnalyserNode.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/AnalyserNode.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/AnalyserNode.hs
@@ -1,4 +1,9 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.AnalyserNode
        (js_getFloatFrequencyData, getFloatFrequencyData,
         js_getByteFrequencyData, getByteFrequencyData,
@@ -9,9 +14,10 @@
         setMaxDecibels, js_getMaxDecibels, getMaxDecibels,
         js_setSmoothingTimeConstant, setSmoothingTimeConstant,
         js_getSmoothingTimeConstant, getSmoothingTimeConstant,
-        AnalyserNode, castToAnalyserNode, gTypeAnalyserNode)
+        AnalyserNode(..), gTypeAnalyserNode)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -27,6 +33,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe
         "$1[\"getFloatFrequencyData\"]($2)" js_getFloatFrequencyData ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/AnimationEvent.hs b/src/GHCJS/DOM/JSFFI/Generated/AnimationEvent.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/AnimationEvent.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/AnimationEvent.hs
@@ -1,10 +1,15 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.AnimationEvent
        (js_getAnimationName, getAnimationName, js_getElapsedTime,
-        getElapsedTime, AnimationEvent, castToAnimationEvent,
-        gTypeAnimationEvent)
+        getElapsedTime, AnimationEvent(..), gTypeAnimationEvent)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -20,6 +25,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"animationName\"]"
         js_getAnimationName :: AnimationEvent -> IO JSString
diff --git a/src/GHCJS/DOM/JSFFI/Generated/ApplicationCache.hs b/src/GHCJS/DOM/JSFFI/Generated/ApplicationCache.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/ApplicationCache.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/ApplicationCache.hs
@@ -1,13 +1,19 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.ApplicationCache
        (js_update, update, js_swapCache, swapCache, js_abort, abort,
         pattern UNCACHED, pattern IDLE, pattern CHECKING,
         pattern DOWNLOADING, pattern UPDATEREADY, pattern OBSOLETE,
         js_getStatus, getStatus, checking, error, noUpdate, downloading,
-        progress, updateReady, cached, obsolete, ApplicationCache,
-        castToApplicationCache, gTypeApplicationCache)
+        progress, updateReady, cached, obsolete, ApplicationCache(..),
+        gTypeApplicationCache)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -23,6 +29,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"update\"]()" js_update ::
         ApplicationCache -> IO ()
diff --git a/src/GHCJS/DOM/JSFFI/Generated/Attr.hs b/src/GHCJS/DOM/JSFFI/Generated/Attr.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/Attr.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/Attr.hs
@@ -1,12 +1,18 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.Attr
-       (js_getName, getName, getNameUnchecked, js_getSpecified,
-        getSpecified, js_setValue, setValue, js_getValue, getValue,
-        getValueUnchecked, js_getOwnerElement, getOwnerElement,
-        getOwnerElementUnchecked, js_getIsId, getIsId, Attr, castToAttr,
-        gTypeAttr)
+       (js_getName, getName, getNameUnsafe, getNameUnchecked,
+        js_getSpecified, getSpecified, js_setValue, setValue, js_getValue,
+        getValue, getValueUnsafe, getValueUnchecked, js_getOwnerElement,
+        getOwnerElement, getOwnerElementUnsafe, getOwnerElementUnchecked,
+        js_getIsId, getIsId, Attr(..), gTypeAttr)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -22,6 +28,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"name\"]" js_getName ::
         Attr -> IO (Nullable JSString)
@@ -32,6 +48,14 @@
 getName self = liftIO (fromMaybeJSString <$> (js_getName (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Attr.name Mozilla Attr.name documentation> 
+getNameUnsafe ::
+              (MonadIO m, HasCallStack, FromJSString result) => Attr -> m result
+getNameUnsafe self
+  = liftIO
+      ((fromMaybeJSString <$> (js_getName (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Attr.name Mozilla Attr.name documentation> 
 getNameUnchecked ::
                  (MonadIO m, FromJSString result) => Attr -> m result
 getNameUnchecked self
@@ -62,6 +86,14 @@
 getValue self = liftIO (fromMaybeJSString <$> (js_getValue (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Attr.value Mozilla Attr.value documentation> 
+getValueUnsafe ::
+               (MonadIO m, HasCallStack, FromJSString result) => Attr -> m result
+getValueUnsafe self
+  = liftIO
+      ((fromMaybeJSString <$> (js_getValue (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Attr.value Mozilla Attr.value documentation> 
 getValueUnchecked ::
                   (MonadIO m, FromJSString result) => Attr -> m result
 getValueUnchecked self
@@ -74,6 +106,14 @@
 getOwnerElement :: (MonadIO m) => Attr -> m (Maybe Element)
 getOwnerElement self
   = liftIO (nullableToMaybe <$> (js_getOwnerElement (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Attr.ownerElement Mozilla Attr.ownerElement documentation> 
+getOwnerElementUnsafe ::
+                      (MonadIO m, HasCallStack) => Attr -> m Element
+getOwnerElementUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getOwnerElement (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Attr.ownerElement Mozilla Attr.ownerElement documentation> 
 getOwnerElementUnchecked :: (MonadIO m) => Attr -> m Element
diff --git a/src/GHCJS/DOM/JSFFI/Generated/AudioBuffer.hs b/src/GHCJS/DOM/JSFFI/Generated/AudioBuffer.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/AudioBuffer.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/AudioBuffer.hs
@@ -1,12 +1,19 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.AudioBuffer
        (js_getChannelData, getChannelData, getChannelData_,
-        getChannelDataUnchecked, js_getLength, getLength, js_getDuration,
-        getDuration, js_getSampleRate, getSampleRate, js_setGain, setGain,
-        js_getGain, getGain, js_getNumberOfChannels, getNumberOfChannels,
-        AudioBuffer, castToAudioBuffer, gTypeAudioBuffer)
+        getChannelDataUnsafe, getChannelDataUnchecked, js_getLength,
+        getLength, js_getDuration, getDuration, js_getSampleRate,
+        getSampleRate, js_setGain, setGain, js_getGain, getGain,
+        js_getNumberOfChannels, getNumberOfChannels, AudioBuffer(..),
+        gTypeAudioBuffer)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -22,6 +29,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"getChannelData\"]($2)"
         js_getChannelData ::
@@ -38,6 +55,14 @@
 getChannelData_ :: (MonadIO m) => AudioBuffer -> Word -> m ()
 getChannelData_ self channelIndex
   = liftIO (void (js_getChannelData (self) channelIndex))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/AudioBuffer.getChannelData Mozilla AudioBuffer.getChannelData documentation> 
+getChannelDataUnsafe ::
+                     (MonadIO m, HasCallStack) => AudioBuffer -> Word -> m Float32Array
+getChannelDataUnsafe self channelIndex
+  = liftIO
+      ((nullableToMaybe <$> (js_getChannelData (self) channelIndex)) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/AudioBuffer.getChannelData Mozilla AudioBuffer.getChannelData documentation> 
 getChannelDataUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/AudioBufferCallback.hs b/src/GHCJS/DOM/JSFFI/Generated/AudioBufferCallback.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/AudioBufferCallback.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/AudioBufferCallback.hs
@@ -1,9 +1,15 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.AudioBufferCallback
        (newAudioBufferCallback, newAudioBufferCallbackSync,
         newAudioBufferCallbackAsync, AudioBufferCallback)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -19,6 +25,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/AudioBufferCallback Mozilla AudioBufferCallback documentation> 
 newAudioBufferCallback ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/AudioBufferSourceNode.hs b/src/GHCJS/DOM/JSFFI/Generated/AudioBufferSourceNode.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/AudioBufferSourceNode.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/AudioBufferSourceNode.hs
@@ -1,19 +1,26 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.AudioBufferSourceNode
        (js_start, start, js_stop, stop, js_noteOn, noteOn, js_noteGrainOn,
         noteGrainOn, js_noteOff, noteOff, pattern UNSCHEDULED_STATE,
         pattern SCHEDULED_STATE, pattern PLAYING_STATE,
         pattern FINISHED_STATE, js_setBuffer, setBuffer, js_getBuffer,
-        getBuffer, getBufferUnchecked, js_getPlaybackState,
-        getPlaybackState, js_getGain, getGain, getGainUnchecked,
-        js_getPlaybackRate, getPlaybackRate, getPlaybackRateUnchecked,
+        getBuffer, getBufferUnsafe, getBufferUnchecked,
+        js_getPlaybackState, getPlaybackState, js_getGain, getGain,
+        getGainUnsafe, getGainUnchecked, js_getPlaybackRate,
+        getPlaybackRate, getPlaybackRateUnsafe, getPlaybackRateUnchecked,
         js_setLoop, setLoop, js_getLoop, getLoop, js_setLoopStart,
         setLoopStart, js_getLoopStart, getLoopStart, js_setLoopEnd,
         setLoopEnd, js_getLoopEnd, getLoopEnd, js_setLooping, setLooping,
-        js_getLooping, getLooping, ended, AudioBufferSourceNode,
-        castToAudioBufferSourceNode, gTypeAudioBufferSourceNode)
+        js_getLooping, getLooping, ended, AudioBufferSourceNode(..),
+        gTypeAudioBufferSourceNode)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -29,6 +36,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"start\"]($2, $3, $4)"
         js_start ::
@@ -96,6 +113,14 @@
 getBuffer self = liftIO (nullableToMaybe <$> (js_getBuffer (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/AudioBufferSourceNode.buffer Mozilla AudioBufferSourceNode.buffer documentation> 
+getBufferUnsafe ::
+                (MonadIO m, HasCallStack) => AudioBufferSourceNode -> m AudioBuffer
+getBufferUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getBuffer (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/AudioBufferSourceNode.buffer Mozilla AudioBufferSourceNode.buffer documentation> 
 getBufferUnchecked ::
                    (MonadIO m) => AudioBufferSourceNode -> m AudioBuffer
 getBufferUnchecked self
@@ -117,6 +142,14 @@
 getGain self = liftIO (nullableToMaybe <$> (js_getGain (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/AudioBufferSourceNode.gain Mozilla AudioBufferSourceNode.gain documentation> 
+getGainUnsafe ::
+              (MonadIO m, HasCallStack) => AudioBufferSourceNode -> m AudioParam
+getGainUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getGain (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/AudioBufferSourceNode.gain Mozilla AudioBufferSourceNode.gain documentation> 
 getGainUnchecked ::
                  (MonadIO m) => AudioBufferSourceNode -> m AudioParam
 getGainUnchecked self
@@ -131,6 +164,14 @@
                 (MonadIO m) => AudioBufferSourceNode -> m (Maybe AudioParam)
 getPlaybackRate self
   = liftIO (nullableToMaybe <$> (js_getPlaybackRate (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/AudioBufferSourceNode.playbackRate Mozilla AudioBufferSourceNode.playbackRate documentation> 
+getPlaybackRateUnsafe ::
+                      (MonadIO m, HasCallStack) => AudioBufferSourceNode -> m AudioParam
+getPlaybackRateUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getPlaybackRate (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/AudioBufferSourceNode.playbackRate Mozilla AudioBufferSourceNode.playbackRate documentation> 
 getPlaybackRateUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/AudioContext.hs b/src/GHCJS/DOM/JSFFI/Generated/AudioContext.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/AudioContext.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/AudioContext.hs
@@ -1,52 +1,68 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.AudioContext
        (js_newAudioContext, newAudioContext, js_createBuffer,
-        createBuffer, createBuffer_, createBufferUnchecked,
-        js_createBufferFromArrayBuffer, createBufferFromArrayBuffer,
-        createBufferFromArrayBuffer_, createBufferFromArrayBufferUnchecked,
-        js_decodeAudioData, decodeAudioData, js_createBufferSource,
-        createBufferSource, createBufferSource_,
+        createBuffer, createBuffer_, createBufferUnsafe,
+        createBufferUnchecked, js_createBufferFromArrayBuffer,
+        createBufferFromArrayBuffer, createBufferFromArrayBuffer_,
+        createBufferFromArrayBufferUnsafe,
+        createBufferFromArrayBufferUnchecked, js_decodeAudioData,
+        decodeAudioData, js_createBufferSource, createBufferSource,
+        createBufferSource_, createBufferSourceUnsafe,
         createBufferSourceUnchecked, js_createMediaElementSource,
         createMediaElementSource, createMediaElementSource_,
-        createMediaElementSourceUnchecked, js_createMediaStreamSource,
-        createMediaStreamSource, createMediaStreamSource_,
+        createMediaElementSourceUnsafe, createMediaElementSourceUnchecked,
+        js_createMediaStreamSource, createMediaStreamSource,
+        createMediaStreamSource_, createMediaStreamSourceUnsafe,
         createMediaStreamSourceUnchecked, js_createMediaStreamDestination,
         createMediaStreamDestination, createMediaStreamDestination_,
+        createMediaStreamDestinationUnsafe,
         createMediaStreamDestinationUnchecked, js_createGain, createGain,
-        createGain_, createGainUnchecked, js_createDelay, createDelay,
-        createDelay_, createDelayUnchecked, js_createBiquadFilter,
-        createBiquadFilter, createBiquadFilter_,
-        createBiquadFilterUnchecked, js_createWaveShaper, createWaveShaper,
-        createWaveShaper_, createWaveShaperUnchecked, js_createPanner,
-        createPanner, createPanner_, createPannerUnchecked,
-        js_createConvolver, createConvolver, createConvolver_,
-        createConvolverUnchecked, js_createDynamicsCompressor,
-        createDynamicsCompressor, createDynamicsCompressor_,
+        createGain_, createGainUnsafe, createGainUnchecked, js_createDelay,
+        createDelay, createDelay_, createDelayUnsafe, createDelayUnchecked,
+        js_createBiquadFilter, createBiquadFilter, createBiquadFilter_,
+        createBiquadFilterUnsafe, createBiquadFilterUnchecked,
+        js_createWaveShaper, createWaveShaper, createWaveShaper_,
+        createWaveShaperUnsafe, createWaveShaperUnchecked, js_createPanner,
+        createPanner, createPanner_, createPannerUnsafe,
+        createPannerUnchecked, js_createConvolver, createConvolver,
+        createConvolver_, createConvolverUnsafe, createConvolverUnchecked,
+        js_createDynamicsCompressor, createDynamicsCompressor,
+        createDynamicsCompressor_, createDynamicsCompressorUnsafe,
         createDynamicsCompressorUnchecked, js_createAnalyser,
-        createAnalyser, createAnalyser_, createAnalyserUnchecked,
-        js_createScriptProcessor, createScriptProcessor,
-        createScriptProcessor_, createScriptProcessorUnchecked,
+        createAnalyser, createAnalyser_, createAnalyserUnsafe,
+        createAnalyserUnchecked, js_createScriptProcessor,
+        createScriptProcessor, createScriptProcessor_,
+        createScriptProcessorUnsafe, createScriptProcessorUnchecked,
         js_createOscillator, createOscillator, createOscillator_,
-        createOscillatorUnchecked, js_createPeriodicWave,
-        createPeriodicWave, createPeriodicWave_,
-        createPeriodicWaveUnchecked, js_createChannelSplitter,
-        createChannelSplitter, createChannelSplitter_,
+        createOscillatorUnsafe, createOscillatorUnchecked,
+        js_createPeriodicWave, createPeriodicWave, createPeriodicWave_,
+        createPeriodicWaveUnsafe, createPeriodicWaveUnchecked,
+        js_createChannelSplitter, createChannelSplitter,
+        createChannelSplitter_, createChannelSplitterUnsafe,
         createChannelSplitterUnchecked, js_createChannelMerger,
         createChannelMerger, createChannelMerger_,
-        createChannelMergerUnchecked, js_startRendering, startRendering,
-        js_createGainNode, createGainNode, createGainNode_,
+        createChannelMergerUnsafe, createChannelMergerUnchecked,
+        js_startRendering, startRendering, js_createGainNode,
+        createGainNode, createGainNode_, createGainNodeUnsafe,
         createGainNodeUnchecked, js_createDelayNode, createDelayNode,
-        createDelayNode_, createDelayNodeUnchecked,
+        createDelayNode_, createDelayNodeUnsafe, createDelayNodeUnchecked,
         js_createJavaScriptNode, createJavaScriptNode,
-        createJavaScriptNode_, createJavaScriptNodeUnchecked,
-        js_getDestination, getDestination, getDestinationUnchecked,
-        js_getCurrentTime, getCurrentTime, js_getSampleRate, getSampleRate,
-        js_getListener, getListener, getListenerUnchecked,
+        createJavaScriptNode_, createJavaScriptNodeUnsafe,
+        createJavaScriptNodeUnchecked, js_getDestination, getDestination,
+        getDestinationUnsafe, getDestinationUnchecked, js_getCurrentTime,
+        getCurrentTime, js_getSampleRate, getSampleRate, js_getListener,
+        getListener, getListenerUnsafe, getListenerUnchecked,
         js_getActiveSourceCount, getActiveSourceCount, complete,
-        AudioContext, castToAudioContext, gTypeAudioContext,
-        IsAudioContext, toAudioContext)
+        AudioContext(..), gTypeAudioContext, IsAudioContext,
+        toAudioContext)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -62,6 +78,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe
         "new (window[\"AudioContext\"]\n||\nwindow[\"webkitAudioContext\"])()"
@@ -98,6 +124,18 @@
             sampleRate))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/AudioContext.createBuffer Mozilla AudioContext.createBuffer documentation> 
+createBufferUnsafe ::
+                   (MonadIO m, IsAudioContext self, HasCallStack) =>
+                     self -> Word -> Word -> Float -> m AudioBuffer
+createBufferUnsafe self numberOfChannels numberOfFrames sampleRate
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_createBuffer (toAudioContext self) numberOfChannels
+             numberOfFrames
+             sampleRate))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/AudioContext.createBuffer Mozilla AudioContext.createBuffer documentation> 
 createBufferUnchecked ::
                       (MonadIO m, IsAudioContext self) =>
                         self -> Word -> Word -> Float -> m AudioBuffer
@@ -137,6 +175,19 @@
             mixToMono))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/AudioContext.createBuffer Mozilla AudioContext.createBuffer documentation> 
+createBufferFromArrayBufferUnsafe ::
+                                  (MonadIO m, IsAudioContext self, IsArrayBuffer buffer,
+                                   HasCallStack) =>
+                                    self -> Maybe buffer -> Bool -> m AudioBuffer
+createBufferFromArrayBufferUnsafe self buffer mixToMono
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_createBufferFromArrayBuffer (toAudioContext self)
+             (maybeToNullable (fmap toArrayBuffer buffer))
+             mixToMono))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/AudioContext.createBuffer Mozilla AudioContext.createBuffer documentation> 
 createBufferFromArrayBufferUnchecked ::
                                      (MonadIO m, IsAudioContext self, IsArrayBuffer buffer) =>
                                        self -> Maybe buffer -> Bool -> m AudioBuffer
@@ -186,6 +237,16 @@
   = liftIO (void (js_createBufferSource (toAudioContext self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/AudioContext.createBufferSource Mozilla AudioContext.createBufferSource documentation> 
+createBufferSourceUnsafe ::
+                         (MonadIO m, IsAudioContext self, HasCallStack) =>
+                           self -> m AudioBufferSourceNode
+createBufferSourceUnsafe self
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_createBufferSource (toAudioContext self)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/AudioContext.createBufferSource Mozilla AudioContext.createBufferSource documentation> 
 createBufferSourceUnchecked ::
                             (MonadIO m, IsAudioContext self) => self -> m AudioBufferSourceNode
 createBufferSourceUnchecked self
@@ -223,6 +284,18 @@
             (maybeToNullable (fmap toHTMLMediaElement mediaElement))))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/AudioContext.createMediaElementSource Mozilla AudioContext.createMediaElementSource documentation> 
+createMediaElementSourceUnsafe ::
+                               (MonadIO m, IsAudioContext self, IsHTMLMediaElement mediaElement,
+                                HasCallStack) =>
+                                 self -> Maybe mediaElement -> m MediaElementAudioSourceNode
+createMediaElementSourceUnsafe self mediaElement
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_createMediaElementSource (toAudioContext self)
+             (maybeToNullable (fmap toHTMLMediaElement mediaElement))))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/AudioContext.createMediaElementSource Mozilla AudioContext.createMediaElementSource documentation> 
 createMediaElementSourceUnchecked ::
                                   (MonadIO m, IsAudioContext self,
                                    IsHTMLMediaElement mediaElement) =>
@@ -259,6 +332,17 @@
             (maybeToNullable mediaStream)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/AudioContext.createMediaStreamSource Mozilla AudioContext.createMediaStreamSource documentation> 
+createMediaStreamSourceUnsafe ::
+                              (MonadIO m, IsAudioContext self, HasCallStack) =>
+                                self -> Maybe MediaStream -> m MediaStreamAudioSourceNode
+createMediaStreamSourceUnsafe self mediaStream
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_createMediaStreamSource (toAudioContext self)
+             (maybeToNullable mediaStream)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/AudioContext.createMediaStreamSource Mozilla AudioContext.createMediaStreamSource documentation> 
 createMediaStreamSourceUnchecked ::
                                  (MonadIO m, IsAudioContext self) =>
                                    self -> Maybe MediaStream -> m MediaStreamAudioSourceNode
@@ -290,6 +374,16 @@
       (void (js_createMediaStreamDestination (toAudioContext self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/AudioContext.createMediaStreamDestination Mozilla AudioContext.createMediaStreamDestination documentation> 
+createMediaStreamDestinationUnsafe ::
+                                   (MonadIO m, IsAudioContext self, HasCallStack) =>
+                                     self -> m MediaStreamAudioDestinationNode
+createMediaStreamDestinationUnsafe self
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_createMediaStreamDestination (toAudioContext self)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/AudioContext.createMediaStreamDestination Mozilla AudioContext.createMediaStreamDestination documentation> 
 createMediaStreamDestinationUnchecked ::
                                       (MonadIO m, IsAudioContext self) =>
                                         self -> m MediaStreamAudioDestinationNode
@@ -314,6 +408,15 @@
   = liftIO (void (js_createGain (toAudioContext self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/AudioContext.createGain Mozilla AudioContext.createGain documentation> 
+createGainUnsafe ::
+                 (MonadIO m, IsAudioContext self, HasCallStack) =>
+                   self -> m GainNode
+createGainUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_createGain (toAudioContext self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/AudioContext.createGain Mozilla AudioContext.createGain documentation> 
 createGainUnchecked ::
                     (MonadIO m, IsAudioContext self) => self -> m GainNode
 createGainUnchecked self
@@ -340,6 +443,16 @@
   = liftIO (void (js_createDelay (toAudioContext self) maxDelayTime))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/AudioContext.createDelay Mozilla AudioContext.createDelay documentation> 
+createDelayUnsafe ::
+                  (MonadIO m, IsAudioContext self, HasCallStack) =>
+                    self -> Double -> m DelayNode
+createDelayUnsafe self maxDelayTime
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_createDelay (toAudioContext self) maxDelayTime))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/AudioContext.createDelay Mozilla AudioContext.createDelay documentation> 
 createDelayUnchecked ::
                      (MonadIO m, IsAudioContext self) => self -> Double -> m DelayNode
 createDelayUnchecked self maxDelayTime
@@ -366,6 +479,16 @@
   = liftIO (void (js_createBiquadFilter (toAudioContext self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/AudioContext.createBiquadFilter Mozilla AudioContext.createBiquadFilter documentation> 
+createBiquadFilterUnsafe ::
+                         (MonadIO m, IsAudioContext self, HasCallStack) =>
+                           self -> m BiquadFilterNode
+createBiquadFilterUnsafe self
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_createBiquadFilter (toAudioContext self)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/AudioContext.createBiquadFilter Mozilla AudioContext.createBiquadFilter documentation> 
 createBiquadFilterUnchecked ::
                             (MonadIO m, IsAudioContext self) => self -> m BiquadFilterNode
 createBiquadFilterUnchecked self
@@ -391,6 +514,15 @@
   = liftIO (void (js_createWaveShaper (toAudioContext self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/AudioContext.createWaveShaper Mozilla AudioContext.createWaveShaper documentation> 
+createWaveShaperUnsafe ::
+                       (MonadIO m, IsAudioContext self, HasCallStack) =>
+                         self -> m WaveShaperNode
+createWaveShaperUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_createWaveShaper (toAudioContext self)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/AudioContext.createWaveShaper Mozilla AudioContext.createWaveShaper documentation> 
 createWaveShaperUnchecked ::
                           (MonadIO m, IsAudioContext self) => self -> m WaveShaperNode
 createWaveShaperUnchecked self
@@ -414,6 +546,15 @@
   = liftIO (void (js_createPanner (toAudioContext self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/AudioContext.createPanner Mozilla AudioContext.createPanner documentation> 
+createPannerUnsafe ::
+                   (MonadIO m, IsAudioContext self, HasCallStack) =>
+                     self -> m PannerNode
+createPannerUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_createPanner (toAudioContext self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/AudioContext.createPanner Mozilla AudioContext.createPanner documentation> 
 createPannerUnchecked ::
                       (MonadIO m, IsAudioContext self) => self -> m PannerNode
 createPannerUnchecked self
@@ -438,6 +579,15 @@
   = liftIO (void (js_createConvolver (toAudioContext self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/AudioContext.createConvolver Mozilla AudioContext.createConvolver documentation> 
+createConvolverUnsafe ::
+                      (MonadIO m, IsAudioContext self, HasCallStack) =>
+                        self -> m ConvolverNode
+createConvolverUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_createConvolver (toAudioContext self)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/AudioContext.createConvolver Mozilla AudioContext.createConvolver documentation> 
 createConvolverUnchecked ::
                          (MonadIO m, IsAudioContext self) => self -> m ConvolverNode
 createConvolverUnchecked self
@@ -465,6 +615,16 @@
   = liftIO (void (js_createDynamicsCompressor (toAudioContext self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/AudioContext.createDynamicsCompressor Mozilla AudioContext.createDynamicsCompressor documentation> 
+createDynamicsCompressorUnsafe ::
+                               (MonadIO m, IsAudioContext self, HasCallStack) =>
+                                 self -> m DynamicsCompressorNode
+createDynamicsCompressorUnsafe self
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_createDynamicsCompressor (toAudioContext self)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/AudioContext.createDynamicsCompressor Mozilla AudioContext.createDynamicsCompressor documentation> 
 createDynamicsCompressorUnchecked ::
                                   (MonadIO m, IsAudioContext self) =>
                                     self -> m DynamicsCompressorNode
@@ -489,6 +649,15 @@
   = liftIO (void (js_createAnalyser (toAudioContext self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/AudioContext.createAnalyser Mozilla AudioContext.createAnalyser documentation> 
+createAnalyserUnsafe ::
+                     (MonadIO m, IsAudioContext self, HasCallStack) =>
+                       self -> m AnalyserNode
+createAnalyserUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_createAnalyser (toAudioContext self)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/AudioContext.createAnalyser Mozilla AudioContext.createAnalyser documentation> 
 createAnalyserUnchecked ::
                         (MonadIO m, IsAudioContext self) => self -> m AnalyserNode
 createAnalyserUnchecked self
@@ -527,6 +696,19 @@
             numberOfOutputChannels))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/AudioContext.createScriptProcessor Mozilla AudioContext.createScriptProcessor documentation> 
+createScriptProcessorUnsafe ::
+                            (MonadIO m, IsAudioContext self, HasCallStack) =>
+                              self -> Word -> Word -> Word -> m ScriptProcessorNode
+createScriptProcessorUnsafe self bufferSize numberOfInputChannels
+  numberOfOutputChannels
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_createScriptProcessor (toAudioContext self) bufferSize
+             numberOfInputChannels
+             numberOfOutputChannels))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/AudioContext.createScriptProcessor Mozilla AudioContext.createScriptProcessor documentation> 
 createScriptProcessorUnchecked ::
                                (MonadIO m, IsAudioContext self) =>
                                  self -> Word -> Word -> Word -> m ScriptProcessorNode
@@ -556,6 +738,15 @@
   = liftIO (void (js_createOscillator (toAudioContext self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/AudioContext.createOscillator Mozilla AudioContext.createOscillator documentation> 
+createOscillatorUnsafe ::
+                       (MonadIO m, IsAudioContext self, HasCallStack) =>
+                         self -> m OscillatorNode
+createOscillatorUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_createOscillator (toAudioContext self)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/AudioContext.createOscillator Mozilla AudioContext.createOscillator documentation> 
 createOscillatorUnchecked ::
                           (MonadIO m, IsAudioContext self) => self -> m OscillatorNode
 createOscillatorUnchecked self
@@ -594,6 +785,19 @@
             (maybeToNullable (fmap toFloat32Array imag))))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/AudioContext.createPeriodicWave Mozilla AudioContext.createPeriodicWave documentation> 
+createPeriodicWaveUnsafe ::
+                         (MonadIO m, IsAudioContext self, IsFloat32Array real,
+                          IsFloat32Array imag, HasCallStack) =>
+                           self -> Maybe real -> Maybe imag -> m PeriodicWave
+createPeriodicWaveUnsafe self real imag
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_createPeriodicWave (toAudioContext self)
+             (maybeToNullable (fmap toFloat32Array real))
+             (maybeToNullable (fmap toFloat32Array imag))))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/AudioContext.createPeriodicWave Mozilla AudioContext.createPeriodicWave documentation> 
 createPeriodicWaveUnchecked ::
                             (MonadIO m, IsAudioContext self, IsFloat32Array real,
                              IsFloat32Array imag) =>
@@ -627,6 +831,16 @@
          (js_createChannelSplitter (toAudioContext self) numberOfOutputs))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/AudioContext.createChannelSplitter Mozilla AudioContext.createChannelSplitter documentation> 
+createChannelSplitterUnsafe ::
+                            (MonadIO m, IsAudioContext self, HasCallStack) =>
+                              self -> Word -> m ChannelSplitterNode
+createChannelSplitterUnsafe self numberOfOutputs
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_createChannelSplitter (toAudioContext self) numberOfOutputs))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/AudioContext.createChannelSplitter Mozilla AudioContext.createChannelSplitter documentation> 
 createChannelSplitterUnchecked ::
                                (MonadIO m, IsAudioContext self) =>
                                  self -> Word -> m ChannelSplitterNode
@@ -657,6 +871,16 @@
          (js_createChannelMerger (toAudioContext self) numberOfInputs))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/AudioContext.createChannelMerger Mozilla AudioContext.createChannelMerger documentation> 
+createChannelMergerUnsafe ::
+                          (MonadIO m, IsAudioContext self, HasCallStack) =>
+                            self -> Word -> m ChannelMergerNode
+createChannelMergerUnsafe self numberOfInputs
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_createChannelMerger (toAudioContext self) numberOfInputs))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/AudioContext.createChannelMerger Mozilla AudioContext.createChannelMerger documentation> 
 createChannelMergerUnchecked ::
                              (MonadIO m, IsAudioContext self) =>
                                self -> Word -> m ChannelMergerNode
@@ -689,6 +913,15 @@
   = liftIO (void (js_createGainNode (toAudioContext self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/AudioContext.createGainNode Mozilla AudioContext.createGainNode documentation> 
+createGainNodeUnsafe ::
+                     (MonadIO m, IsAudioContext self, HasCallStack) =>
+                       self -> m GainNode
+createGainNodeUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_createGainNode (toAudioContext self)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/AudioContext.createGainNode Mozilla AudioContext.createGainNode documentation> 
 createGainNodeUnchecked ::
                         (MonadIO m, IsAudioContext self) => self -> m GainNode
 createGainNodeUnchecked self
@@ -717,6 +950,16 @@
       (void (js_createDelayNode (toAudioContext self) maxDelayTime))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/AudioContext.createDelayNode Mozilla AudioContext.createDelayNode documentation> 
+createDelayNodeUnsafe ::
+                      (MonadIO m, IsAudioContext self, HasCallStack) =>
+                        self -> Double -> m DelayNode
+createDelayNodeUnsafe self maxDelayTime
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_createDelayNode (toAudioContext self) maxDelayTime))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/AudioContext.createDelayNode Mozilla AudioContext.createDelayNode documentation> 
 createDelayNodeUnchecked ::
                          (MonadIO m, IsAudioContext self) => self -> Double -> m DelayNode
 createDelayNodeUnchecked self maxDelayTime
@@ -755,6 +998,19 @@
             numberOfOutputChannels))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/AudioContext.createJavaScriptNode Mozilla AudioContext.createJavaScriptNode documentation> 
+createJavaScriptNodeUnsafe ::
+                           (MonadIO m, IsAudioContext self, HasCallStack) =>
+                             self -> Word -> Word -> Word -> m ScriptProcessorNode
+createJavaScriptNodeUnsafe self bufferSize numberOfInputChannels
+  numberOfOutputChannels
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_createJavaScriptNode (toAudioContext self) bufferSize
+             numberOfInputChannels
+             numberOfOutputChannels))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/AudioContext.createJavaScriptNode Mozilla AudioContext.createJavaScriptNode documentation> 
 createJavaScriptNodeUnchecked ::
                               (MonadIO m, IsAudioContext self) =>
                                 self -> Word -> Word -> Word -> m ScriptProcessorNode
@@ -779,6 +1035,15 @@
       (nullableToMaybe <$> (js_getDestination (toAudioContext self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/AudioContext.destination Mozilla AudioContext.destination documentation> 
+getDestinationUnsafe ::
+                     (MonadIO m, IsAudioContext self, HasCallStack) =>
+                       self -> m AudioDestinationNode
+getDestinationUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getDestination (toAudioContext self)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/AudioContext.destination Mozilla AudioContext.destination documentation> 
 getDestinationUnchecked ::
                         (MonadIO m, IsAudioContext self) => self -> m AudioDestinationNode
 getDestinationUnchecked self
@@ -813,6 +1078,15 @@
 getListener self
   = liftIO
       (nullableToMaybe <$> (js_getListener (toAudioContext self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/AudioContext.listener Mozilla AudioContext.listener documentation> 
+getListenerUnsafe ::
+                  (MonadIO m, IsAudioContext self, HasCallStack) =>
+                    self -> m AudioListener
+getListenerUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getListener (toAudioContext self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/AudioContext.listener Mozilla AudioContext.listener documentation> 
 getListenerUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/AudioDestinationNode.hs b/src/GHCJS/DOM/JSFFI/Generated/AudioDestinationNode.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/AudioDestinationNode.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/AudioDestinationNode.hs
@@ -1,9 +1,15 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.AudioDestinationNode
-       (js_getMaxChannelCount, getMaxChannelCount, AudioDestinationNode,
-        castToAudioDestinationNode, gTypeAudioDestinationNode)
+       (js_getMaxChannelCount, getMaxChannelCount,
+        AudioDestinationNode(..), gTypeAudioDestinationNode)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -19,6 +25,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"maxChannelCount\"]"
         js_getMaxChannelCount :: AudioDestinationNode -> IO Word
diff --git a/src/GHCJS/DOM/JSFFI/Generated/AudioListener.hs b/src/GHCJS/DOM/JSFFI/Generated/AudioListener.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/AudioListener.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/AudioListener.hs
@@ -1,12 +1,18 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.AudioListener
        (js_setPosition, setPosition, js_setOrientation, setOrientation,
         js_setVelocity, setVelocity, js_setDopplerFactor, setDopplerFactor,
         js_getDopplerFactor, getDopplerFactor, js_setSpeedOfSound,
         setSpeedOfSound, js_getSpeedOfSound, getSpeedOfSound,
-        AudioListener, castToAudioListener, gTypeAudioListener)
+        AudioListener(..), gTypeAudioListener)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -22,6 +28,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"setPosition\"]($2, $3, $4)"
         js_setPosition :: AudioListener -> Float -> Float -> Float -> IO ()
diff --git a/src/GHCJS/DOM/JSFFI/Generated/AudioNode.hs b/src/GHCJS/DOM/JSFFI/Generated/AudioNode.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/AudioNode.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/AudioNode.hs
@@ -1,16 +1,23 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.AudioNode
        (js_connect, connect, js_connectParam, connectParam, js_disconnect,
-        disconnect, js_getContext, getContext, getContextUnchecked,
-        js_getNumberOfInputs, getNumberOfInputs, js_getNumberOfOutputs,
-        getNumberOfOutputs, js_setChannelCount, setChannelCount,
-        js_getChannelCount, getChannelCount, js_setChannelCountMode,
-        setChannelCountMode, js_getChannelCountMode, getChannelCountMode,
+        disconnect, js_getContext, getContext, getContextUnsafe,
+        getContextUnchecked, js_getNumberOfInputs, getNumberOfInputs,
+        js_getNumberOfOutputs, getNumberOfOutputs, js_setChannelCount,
+        setChannelCount, js_getChannelCount, getChannelCount,
+        js_setChannelCountMode, setChannelCountMode,
+        js_getChannelCountMode, getChannelCountMode,
         js_setChannelInterpretation, setChannelInterpretation,
-        js_getChannelInterpretation, getChannelInterpretation, AudioNode,
-        castToAudioNode, gTypeAudioNode, IsAudioNode, toAudioNode)
+        js_getChannelInterpretation, getChannelInterpretation,
+        AudioNode(..), gTypeAudioNode, IsAudioNode, toAudioNode)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -26,6 +33,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"connect\"]($2, $3, $4)"
         js_connect ::
@@ -71,6 +88,15 @@
            (MonadIO m, IsAudioNode self) => self -> m (Maybe AudioContext)
 getContext self
   = liftIO (nullableToMaybe <$> (js_getContext (toAudioNode self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/AudioNode.context Mozilla AudioNode.context documentation> 
+getContextUnsafe ::
+                 (MonadIO m, IsAudioNode self, HasCallStack) =>
+                   self -> m AudioContext
+getContextUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getContext (toAudioNode self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/AudioNode.context Mozilla AudioNode.context documentation> 
 getContextUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/AudioParam.hs b/src/GHCJS/DOM/JSFFI/Generated/AudioParam.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/AudioParam.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/AudioParam.hs
@@ -1,4 +1,9 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.AudioParam
        (js_setValueAtTime, setValueAtTime, js_linearRampToValueAtTime,
         linearRampToValueAtTime, js_exponentialRampToValueAtTime,
@@ -8,10 +13,11 @@
         js_setTargetValueAtTime, setTargetValueAtTime, js_setValue,
         setValue, js_getValue, getValue, js_getMinValue, getMinValue,
         js_getMaxValue, getMaxValue, js_getDefaultValue, getDefaultValue,
-        js_getName, getName, js_getUnits, getUnits, AudioParam,
-        castToAudioParam, gTypeAudioParam)
+        js_getName, getName, js_getUnits, getUnits, AudioParam(..),
+        gTypeAudioParam)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -27,6 +33,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"setValueAtTime\"]($2, $3)"
         js_setValueAtTime :: AudioParam -> Float -> Float -> IO ()
diff --git a/src/GHCJS/DOM/JSFFI/Generated/AudioProcessingEvent.hs b/src/GHCJS/DOM/JSFFI/Generated/AudioProcessingEvent.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/AudioProcessingEvent.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/AudioProcessingEvent.hs
@@ -1,11 +1,18 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.AudioProcessingEvent
        (js_getPlaybackTime, getPlaybackTime, js_getInputBuffer,
-        getInputBuffer, getInputBufferUnchecked, js_getOutputBuffer,
-        getOutputBuffer, getOutputBufferUnchecked, AudioProcessingEvent,
-        castToAudioProcessingEvent, gTypeAudioProcessingEvent)
+        getInputBuffer, getInputBufferUnsafe, getInputBufferUnchecked,
+        js_getOutputBuffer, getOutputBuffer, getOutputBufferUnsafe,
+        getOutputBufferUnchecked, AudioProcessingEvent(..),
+        gTypeAudioProcessingEvent)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -21,6 +28,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"playbackTime\"]"
         js_getPlaybackTime :: AudioProcessingEvent -> IO Double
@@ -40,6 +57,14 @@
   = liftIO (nullableToMaybe <$> (js_getInputBuffer (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/AudioProcessingEvent.inputBuffer Mozilla AudioProcessingEvent.inputBuffer documentation> 
+getInputBufferUnsafe ::
+                     (MonadIO m, HasCallStack) => AudioProcessingEvent -> m AudioBuffer
+getInputBufferUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getInputBuffer (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/AudioProcessingEvent.inputBuffer Mozilla AudioProcessingEvent.inputBuffer documentation> 
 getInputBufferUnchecked ::
                         (MonadIO m) => AudioProcessingEvent -> m AudioBuffer
 getInputBufferUnchecked self
@@ -55,6 +80,14 @@
                 (MonadIO m) => AudioProcessingEvent -> m (Maybe AudioBuffer)
 getOutputBuffer self
   = liftIO (nullableToMaybe <$> (js_getOutputBuffer (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/AudioProcessingEvent.outputBuffer Mozilla AudioProcessingEvent.outputBuffer documentation> 
+getOutputBufferUnsafe ::
+                      (MonadIO m, HasCallStack) => AudioProcessingEvent -> m AudioBuffer
+getOutputBufferUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getOutputBuffer (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/AudioProcessingEvent.outputBuffer Mozilla AudioProcessingEvent.outputBuffer documentation> 
 getOutputBufferUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/AudioStreamTrack.hs b/src/GHCJS/DOM/JSFFI/Generated/AudioStreamTrack.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/AudioStreamTrack.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/AudioStreamTrack.hs
@@ -1,9 +1,15 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.AudioStreamTrack
-       (js_newAudioStreamTrack, newAudioStreamTrack, AudioStreamTrack,
-        castToAudioStreamTrack, gTypeAudioStreamTrack)
+       (js_newAudioStreamTrack, newAudioStreamTrack, AudioStreamTrack(..),
+        gTypeAudioStreamTrack)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -19,6 +25,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe
         "new window[\"AudioStreamTrack\"]($1)" js_newAudioStreamTrack ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/AudioTrack.hs b/src/GHCJS/DOM/JSFFI/Generated/AudioTrack.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/AudioTrack.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/AudioTrack.hs
@@ -1,12 +1,18 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.AudioTrack
        (js_getId, getId, js_setKind, setKind, js_getKind, getKind,
         js_getLabel, getLabel, js_setLanguage, setLanguage, js_getLanguage,
         getLanguage, js_setEnabled, setEnabled, js_getEnabled, getEnabled,
-        js_getSourceBuffer, getSourceBuffer, getSourceBufferUnchecked,
-        AudioTrack, castToAudioTrack, gTypeAudioTrack)
+        js_getSourceBuffer, getSourceBuffer, getSourceBufferUnsafe,
+        getSourceBufferUnchecked, AudioTrack(..), gTypeAudioTrack)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -22,6 +28,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"id\"]" js_getId ::
         AudioTrack -> IO JSString
@@ -93,6 +109,14 @@
                 (MonadIO m) => AudioTrack -> m (Maybe SourceBuffer)
 getSourceBuffer self
   = liftIO (nullableToMaybe <$> (js_getSourceBuffer (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/AudioTrack.sourceBuffer Mozilla AudioTrack.sourceBuffer documentation> 
+getSourceBufferUnsafe ::
+                      (MonadIO m, HasCallStack) => AudioTrack -> m SourceBuffer
+getSourceBufferUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getSourceBuffer (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/AudioTrack.sourceBuffer Mozilla AudioTrack.sourceBuffer documentation> 
 getSourceBufferUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/AudioTrackList.hs b/src/GHCJS/DOM/JSFFI/Generated/AudioTrackList.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/AudioTrackList.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/AudioTrackList.hs
@@ -1,11 +1,17 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.AudioTrackList
-       (js_item, item, item_, itemUnchecked, js_getTrackById,
-        getTrackById, getTrackById_, getTrackByIdUnchecked, js_getLength,
-        getLength, change, addTrack, removeTrack, AudioTrackList,
-        castToAudioTrackList, gTypeAudioTrackList)
+       (js_item, item, item_, itemUnsafe, itemUnchecked, js_getTrackById,
+        getTrackById, getTrackById_, getTrackByIdUnsafe,
+        getTrackByIdUnchecked, js_getLength, getLength, change, addTrack,
+        removeTrack, AudioTrackList(..), gTypeAudioTrackList)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -21,6 +27,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"item\"]($2)" js_item ::
         AudioTrackList -> Word -> IO (Nullable AudioTrack)
@@ -36,6 +52,14 @@
 item_ self index = liftIO (void (js_item (self) index))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/AudioTrackList.item Mozilla AudioTrackList.item documentation> 
+itemUnsafe ::
+           (MonadIO m, HasCallStack) => AudioTrackList -> Word -> m AudioTrack
+itemUnsafe self index
+  = liftIO
+      ((nullableToMaybe <$> (js_item (self) index)) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/AudioTrackList.item Mozilla AudioTrackList.item documentation> 
 itemUnchecked ::
               (MonadIO m) => AudioTrackList -> Word -> m AudioTrack
 itemUnchecked self index
@@ -58,6 +82,15 @@
               (MonadIO m, ToJSString id) => AudioTrackList -> id -> m ()
 getTrackById_ self id
   = liftIO (void (js_getTrackById (self) (toJSString id)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/AudioTrackList.getTrackById Mozilla AudioTrackList.getTrackById documentation> 
+getTrackByIdUnsafe ::
+                   (MonadIO m, ToJSString id, HasCallStack) =>
+                     AudioTrackList -> id -> m AudioTrack
+getTrackByIdUnsafe self id
+  = liftIO
+      ((nullableToMaybe <$> (js_getTrackById (self) (toJSString id))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/AudioTrackList.getTrackById Mozilla AudioTrackList.getTrackById documentation> 
 getTrackByIdUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/AutocompleteErrorEvent.hs b/src/GHCJS/DOM/JSFFI/Generated/AutocompleteErrorEvent.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/AutocompleteErrorEvent.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/AutocompleteErrorEvent.hs
@@ -1,9 +1,15 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.AutocompleteErrorEvent
-       (js_getReason, getReason, AutocompleteErrorEvent,
-        castToAutocompleteErrorEvent, gTypeAutocompleteErrorEvent)
+       (js_getReason, getReason, AutocompleteErrorEvent(..),
+        gTypeAutocompleteErrorEvent)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -19,6 +25,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"reason\"]" js_getReason ::
         AutocompleteErrorEvent -> IO JSString
diff --git a/src/GHCJS/DOM/JSFFI/Generated/BarProp.hs b/src/GHCJS/DOM/JSFFI/Generated/BarProp.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/BarProp.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/BarProp.hs
@@ -1,8 +1,13 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.BarProp
-       (js_getVisible, getVisible, BarProp, castToBarProp, gTypeBarProp)
-       where
+       (js_getVisible, getVisible, BarProp(..), gTypeBarProp) where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -18,6 +23,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "($1[\"visible\"] ? 1 : 0)"
         js_getVisible :: BarProp -> IO Bool
diff --git a/src/GHCJS/DOM/JSFFI/Generated/BatteryManager.hs b/src/GHCJS/DOM/JSFFI/Generated/BatteryManager.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/BatteryManager.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/BatteryManager.hs
@@ -1,12 +1,17 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.BatteryManager
        (js_getCharging, getCharging, js_getChargingTime, getChargingTime,
         js_getDischargingTime, getDischargingTime, js_getLevel, getLevel,
         chargingChange, chargingTimeChange, dischargingTimeChange,
-        levelChange, BatteryManager, castToBatteryManager,
-        gTypeBatteryManager)
+        levelChange, BatteryManager(..), gTypeBatteryManager)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -22,6 +27,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "($1[\"charging\"] ? 1 : 0)"
         js_getCharging :: BatteryManager -> IO Bool
diff --git a/src/GHCJS/DOM/JSFFI/Generated/BeforeLoadEvent.hs b/src/GHCJS/DOM/JSFFI/Generated/BeforeLoadEvent.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/BeforeLoadEvent.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/BeforeLoadEvent.hs
@@ -1,9 +1,14 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.BeforeLoadEvent
-       (js_getUrl, getUrl, BeforeLoadEvent, castToBeforeLoadEvent,
-        gTypeBeforeLoadEvent)
+       (js_getUrl, getUrl, BeforeLoadEvent(..), gTypeBeforeLoadEvent)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -19,6 +24,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"url\"]" js_getUrl ::
         BeforeLoadEvent -> IO JSString
diff --git a/src/GHCJS/DOM/JSFFI/Generated/BeforeUnloadEvent.hs b/src/GHCJS/DOM/JSFFI/Generated/BeforeUnloadEvent.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/BeforeUnloadEvent.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/BeforeUnloadEvent.hs
@@ -1,10 +1,15 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.BeforeUnloadEvent
        (js_setReturnValue, setReturnValue, js_getReturnValue,
-        getReturnValue, BeforeUnloadEvent, castToBeforeUnloadEvent,
-        gTypeBeforeUnloadEvent)
+        getReturnValue, BeforeUnloadEvent(..), gTypeBeforeUnloadEvent)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -20,6 +25,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"returnValue\"] = $2;"
         js_setReturnValue :: BeforeUnloadEvent -> JSString -> IO ()
diff --git a/src/GHCJS/DOM/JSFFI/Generated/BiquadFilterNode.hs b/src/GHCJS/DOM/JSFFI/Generated/BiquadFilterNode.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/BiquadFilterNode.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/BiquadFilterNode.hs
@@ -1,15 +1,22 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.BiquadFilterNode
        (js_getFrequencyResponse, getFrequencyResponse, pattern LOWPASS,
         pattern HIGHPASS, pattern BANDPASS, pattern LOWSHELF,
         pattern HIGHSHELF, pattern PEAKING, pattern NOTCH, pattern ALLPASS,
         js_setType, setType, js_getType, getType, js_getFrequency,
-        getFrequency, getFrequencyUnchecked, js_getDetune, getDetune,
-        getDetuneUnchecked, js_getQ, getQ, getQUnchecked, js_getGain,
-        getGain, getGainUnchecked, BiquadFilterNode,
-        castToBiquadFilterNode, gTypeBiquadFilterNode)
+        getFrequency, getFrequencyUnsafe, getFrequencyUnchecked,
+        js_getDetune, getDetune, getDetuneUnsafe, getDetuneUnchecked,
+        js_getQ, getQ, getQUnsafe, getQUnchecked, js_getGain, getGain,
+        getGainUnsafe, getGainUnchecked, BiquadFilterNode(..),
+        gTypeBiquadFilterNode)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -25,6 +32,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe
         "$1[\"getFrequencyResponse\"]($2,\n$3, $4)" js_getFrequencyResponse
@@ -81,6 +98,14 @@
   = liftIO (nullableToMaybe <$> (js_getFrequency (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/BiquadFilterNode.frequency Mozilla BiquadFilterNode.frequency documentation> 
+getFrequencyUnsafe ::
+                   (MonadIO m, HasCallStack) => BiquadFilterNode -> m AudioParam
+getFrequencyUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getFrequency (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/BiquadFilterNode.frequency Mozilla BiquadFilterNode.frequency documentation> 
 getFrequencyUnchecked ::
                       (MonadIO m) => BiquadFilterNode -> m AudioParam
 getFrequencyUnchecked self
@@ -95,6 +120,14 @@
 getDetune self = liftIO (nullableToMaybe <$> (js_getDetune (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/BiquadFilterNode.detune Mozilla BiquadFilterNode.detune documentation> 
+getDetuneUnsafe ::
+                (MonadIO m, HasCallStack) => BiquadFilterNode -> m AudioParam
+getDetuneUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getDetune (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/BiquadFilterNode.detune Mozilla BiquadFilterNode.detune documentation> 
 getDetuneUnchecked ::
                    (MonadIO m) => BiquadFilterNode -> m AudioParam
 getDetuneUnchecked self
@@ -108,6 +141,14 @@
 getQ self = liftIO (nullableToMaybe <$> (js_getQ (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/BiquadFilterNode.Q Mozilla BiquadFilterNode.Q documentation> 
+getQUnsafe ::
+           (MonadIO m, HasCallStack) => BiquadFilterNode -> m AudioParam
+getQUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getQ (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/BiquadFilterNode.Q Mozilla BiquadFilterNode.Q documentation> 
 getQUnchecked :: (MonadIO m) => BiquadFilterNode -> m AudioParam
 getQUnchecked self
   = liftIO (fromJust . nullableToMaybe <$> (js_getQ (self)))
@@ -118,6 +159,14 @@
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/BiquadFilterNode.gain Mozilla BiquadFilterNode.gain documentation> 
 getGain :: (MonadIO m) => BiquadFilterNode -> m (Maybe AudioParam)
 getGain self = liftIO (nullableToMaybe <$> (js_getGain (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/BiquadFilterNode.gain Mozilla BiquadFilterNode.gain documentation> 
+getGainUnsafe ::
+              (MonadIO m, HasCallStack) => BiquadFilterNode -> m AudioParam
+getGainUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getGain (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/BiquadFilterNode.gain Mozilla BiquadFilterNode.gain documentation> 
 getGainUnchecked :: (MonadIO m) => BiquadFilterNode -> m AudioParam
diff --git a/src/GHCJS/DOM/JSFFI/Generated/Blob.hs b/src/GHCJS/DOM/JSFFI/Generated/Blob.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/Blob.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/Blob.hs
@@ -1,10 +1,16 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.Blob
        (js_newBlob, newBlob, js_newBlob', newBlob', js_slice, slice,
-        slice_, sliceUnchecked, js_getSize, getSize, js_getType, getType,
-        Blob, castToBlob, gTypeBlob, IsBlob, toBlob)
+        slice_, sliceUnsafe, sliceUnchecked, js_getSize, getSize,
+        js_getType, getType, Blob(..), gTypeBlob, IsBlob, toBlob)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -20,6 +26,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "new window[\"Blob\"]()"
         js_newBlob :: IO Blob
@@ -63,6 +79,17 @@
       (void
          (js_slice (toBlob self) (fromIntegral start) (fromIntegral end)
             (toMaybeJSString contentType)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Blob.slice Mozilla Blob.slice documentation> 
+sliceUnsafe ::
+            (MonadIO m, IsBlob self, ToJSString contentType, HasCallStack) =>
+              self -> Int64 -> Int64 -> Maybe contentType -> m Blob
+sliceUnsafe self start end contentType
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_slice (toBlob self) (fromIntegral start) (fromIntegral end)
+             (toMaybeJSString contentType)))
+         >>= maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Blob.slice Mozilla Blob.slice documentation> 
 sliceUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/CSS.hs b/src/GHCJS/DOM/JSFFI/Generated/CSS.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/CSS.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/CSS.hs
@@ -1,9 +1,15 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.CSS
        (js_supports2, supports2, supports2_, js_supports, supports,
-        supports_, CSS, castToCSS, gTypeCSS)
+        supports_, CSS(..), gTypeCSS)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -19,6 +25,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe
         "($1[\"supports\"]($2, $3) ? 1 : 0)" js_supports2 ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/CSSCharsetRule.hs b/src/GHCJS/DOM/JSFFI/Generated/CSSCharsetRule.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/CSSCharsetRule.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/CSSCharsetRule.hs
@@ -1,10 +1,16 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.CSSCharsetRule
        (js_setEncoding, setEncoding, js_getEncoding, getEncoding,
-        getEncodingUnchecked, CSSCharsetRule, castToCSSCharsetRule,
+        getEncodingUnsafe, getEncodingUnchecked, CSSCharsetRule(..),
         gTypeCSSCharsetRule)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -20,6 +26,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"encoding\"] = $2;"
         js_setEncoding :: CSSCharsetRule -> Nullable JSString -> IO ()
@@ -39,6 +55,15 @@
               CSSCharsetRule -> m (Maybe result)
 getEncoding self
   = liftIO (fromMaybeJSString <$> (js_getEncoding (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/CSSCharsetRule.encoding Mozilla CSSCharsetRule.encoding documentation> 
+getEncodingUnsafe ::
+                  (MonadIO m, HasCallStack, FromJSString result) =>
+                    CSSCharsetRule -> m result
+getEncodingUnsafe self
+  = liftIO
+      ((fromMaybeJSString <$> (js_getEncoding (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/CSSCharsetRule.encoding Mozilla CSSCharsetRule.encoding documentation> 
 getEncodingUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/CSSFontFaceLoadEvent.hs b/src/GHCJS/DOM/JSFFI/Generated/CSSFontFaceLoadEvent.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/CSSFontFaceLoadEvent.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/CSSFontFaceLoadEvent.hs
@@ -1,10 +1,17 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.CSSFontFaceLoadEvent
-       (js_getFontface, getFontface, getFontfaceUnchecked, js_getError,
-        getError, getErrorUnchecked, CSSFontFaceLoadEvent,
-        castToCSSFontFaceLoadEvent, gTypeCSSFontFaceLoadEvent)
+       (js_getFontface, getFontface, getFontfaceUnsafe,
+        getFontfaceUnchecked, js_getError, getError, getErrorUnsafe,
+        getErrorUnchecked, CSSFontFaceLoadEvent(..),
+        gTypeCSSFontFaceLoadEvent)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -20,6 +27,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"fontface\"]" js_getFontface
         :: CSSFontFaceLoadEvent -> IO (Nullable CSSFontFaceRule)
@@ -31,6 +48,15 @@
   = liftIO (nullableToMaybe <$> (js_getFontface (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/CSSFontFaceLoadEvent.fontface Mozilla CSSFontFaceLoadEvent.fontface documentation> 
+getFontfaceUnsafe ::
+                  (MonadIO m, HasCallStack) =>
+                    CSSFontFaceLoadEvent -> m CSSFontFaceRule
+getFontfaceUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getFontface (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/CSSFontFaceLoadEvent.fontface Mozilla CSSFontFaceLoadEvent.fontface documentation> 
 getFontfaceUnchecked ::
                      (MonadIO m) => CSSFontFaceLoadEvent -> m CSSFontFaceRule
 getFontfaceUnchecked self
@@ -43,6 +69,14 @@
 getError ::
          (MonadIO m) => CSSFontFaceLoadEvent -> m (Maybe DOMError)
 getError self = liftIO (nullableToMaybe <$> (js_getError (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/CSSFontFaceLoadEvent.error Mozilla CSSFontFaceLoadEvent.error documentation> 
+getErrorUnsafe ::
+               (MonadIO m, HasCallStack) => CSSFontFaceLoadEvent -> m DOMError
+getErrorUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getError (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/CSSFontFaceLoadEvent.error Mozilla CSSFontFaceLoadEvent.error documentation> 
 getErrorUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/CSSFontFaceRule.hs b/src/GHCJS/DOM/JSFFI/Generated/CSSFontFaceRule.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/CSSFontFaceRule.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/CSSFontFaceRule.hs
@@ -1,9 +1,15 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.CSSFontFaceRule
-       (js_getStyle, getStyle, getStyleUnchecked, CSSFontFaceRule,
-        castToCSSFontFaceRule, gTypeCSSFontFaceRule)
+       (js_getStyle, getStyle, getStyleUnsafe, getStyleUnchecked,
+        CSSFontFaceRule(..), gTypeCSSFontFaceRule)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -19,6 +25,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"style\"]" js_getStyle ::
         CSSFontFaceRule -> IO (Nullable CSSStyleDeclaration)
@@ -27,6 +43,15 @@
 getStyle ::
          (MonadIO m) => CSSFontFaceRule -> m (Maybe CSSStyleDeclaration)
 getStyle self = liftIO (nullableToMaybe <$> (js_getStyle (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/CSSFontFaceRule.style Mozilla CSSFontFaceRule.style documentation> 
+getStyleUnsafe ::
+               (MonadIO m, HasCallStack) =>
+                 CSSFontFaceRule -> m CSSStyleDeclaration
+getStyleUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getStyle (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/CSSFontFaceRule.style Mozilla CSSFontFaceRule.style documentation> 
 getStyleUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/CSSImportRule.hs b/src/GHCJS/DOM/JSFFI/Generated/CSSImportRule.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/CSSImportRule.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/CSSImportRule.hs
@@ -1,11 +1,17 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.CSSImportRule
-       (js_getHref, getHref, getHrefUnchecked, js_getMedia, getMedia,
-        getMediaUnchecked, js_getStyleSheet, getStyleSheet,
-        getStyleSheetUnchecked, CSSImportRule, castToCSSImportRule,
-        gTypeCSSImportRule)
+       (js_getHref, getHref, getHrefUnsafe, getHrefUnchecked, js_getMedia,
+        getMedia, getMediaUnsafe, getMediaUnchecked, js_getStyleSheet,
+        getStyleSheet, getStyleSheetUnsafe, getStyleSheetUnchecked,
+        CSSImportRule(..), gTypeCSSImportRule)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -21,6 +27,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"href\"]" js_getHref ::
         CSSImportRule -> IO (Nullable JSString)
@@ -32,6 +48,15 @@
 getHref self = liftIO (fromMaybeJSString <$> (js_getHref (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/CSSImportRule.href Mozilla CSSImportRule.href documentation> 
+getHrefUnsafe ::
+              (MonadIO m, HasCallStack, FromJSString result) =>
+                CSSImportRule -> m result
+getHrefUnsafe self
+  = liftIO
+      ((fromMaybeJSString <$> (js_getHref (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/CSSImportRule.href Mozilla CSSImportRule.href documentation> 
 getHrefUnchecked ::
                  (MonadIO m, FromJSString result) => CSSImportRule -> m result
 getHrefUnchecked self
@@ -45,6 +70,14 @@
 getMedia self = liftIO (nullableToMaybe <$> (js_getMedia (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/CSSImportRule.media Mozilla CSSImportRule.media documentation> 
+getMediaUnsafe ::
+               (MonadIO m, HasCallStack) => CSSImportRule -> m MediaList
+getMediaUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getMedia (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/CSSImportRule.media Mozilla CSSImportRule.media documentation> 
 getMediaUnchecked :: (MonadIO m) => CSSImportRule -> m MediaList
 getMediaUnchecked self
   = liftIO (fromJust . nullableToMaybe <$> (js_getMedia (self)))
@@ -57,6 +90,14 @@
               (MonadIO m) => CSSImportRule -> m (Maybe CSSStyleSheet)
 getStyleSheet self
   = liftIO (nullableToMaybe <$> (js_getStyleSheet (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/CSSImportRule.styleSheet Mozilla CSSImportRule.styleSheet documentation> 
+getStyleSheetUnsafe ::
+                    (MonadIO m, HasCallStack) => CSSImportRule -> m CSSStyleSheet
+getStyleSheetUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getStyleSheet (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/CSSImportRule.styleSheet Mozilla CSSImportRule.styleSheet documentation> 
 getStyleSheetUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/CSSKeyframeRule.hs b/src/GHCJS/DOM/JSFFI/Generated/CSSKeyframeRule.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/CSSKeyframeRule.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/CSSKeyframeRule.hs
@@ -1,10 +1,16 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.CSSKeyframeRule
        (js_setKeyText, setKeyText, js_getKeyText, getKeyText, js_getStyle,
-        getStyle, getStyleUnchecked, CSSKeyframeRule,
-        castToCSSKeyframeRule, gTypeCSSKeyframeRule)
+        getStyle, getStyleUnsafe, getStyleUnchecked, CSSKeyframeRule(..),
+        gTypeCSSKeyframeRule)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -20,6 +26,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"keyText\"] = $2;"
         js_setKeyText :: CSSKeyframeRule -> JSString -> IO ()
@@ -45,6 +61,15 @@
 getStyle ::
          (MonadIO m) => CSSKeyframeRule -> m (Maybe CSSStyleDeclaration)
 getStyle self = liftIO (nullableToMaybe <$> (js_getStyle (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/CSSKeyframeRule.style Mozilla CSSKeyframeRule.style documentation> 
+getStyleUnsafe ::
+               (MonadIO m, HasCallStack) =>
+                 CSSKeyframeRule -> m CSSStyleDeclaration
+getStyleUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getStyle (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/CSSKeyframeRule.style Mozilla CSSKeyframeRule.style documentation> 
 getStyleUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/CSSKeyframesRule.hs b/src/GHCJS/DOM/JSFFI/Generated/CSSKeyframesRule.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/CSSKeyframesRule.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/CSSKeyframesRule.hs
@@ -1,13 +1,20 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.CSSKeyframesRule
        (js_insertRule, insertRule, js_appendRule, appendRule,
         js_deleteRule, deleteRule, js_findRule, findRule, findRule_,
-        findRuleUnchecked, js__get, _get, _get_, _getUnchecked, js_setName,
-        setName, js_getName, getName, getNameUnchecked, js_getCssRules,
-        getCssRules, getCssRulesUnchecked, CSSKeyframesRule,
-        castToCSSKeyframesRule, gTypeCSSKeyframesRule)
+        findRuleUnsafe, findRuleUnchecked, js__get, _get, _get_,
+        _getUnsafe, _getUnchecked, js_setName, setName, js_getName,
+        getName, getNameUnsafe, getNameUnchecked, js_getCssRules,
+        getCssRules, getCssRulesUnsafe, getCssRulesUnchecked,
+        CSSKeyframesRule(..), gTypeCSSKeyframesRule)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -23,6 +30,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"insertRule\"]($2)"
         js_insertRule :: CSSKeyframesRule -> JSString -> IO ()
@@ -69,6 +86,15 @@
   = liftIO (void (js_findRule (self) (toJSString key)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/CSSKeyframesRule.findRule Mozilla CSSKeyframesRule.findRule documentation> 
+findRuleUnsafe ::
+               (MonadIO m, ToJSString key, HasCallStack) =>
+                 CSSKeyframesRule -> key -> m CSSKeyframeRule
+findRuleUnsafe self key
+  = liftIO
+      ((nullableToMaybe <$> (js_findRule (self) (toJSString key))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/CSSKeyframesRule.findRule Mozilla CSSKeyframesRule.findRule documentation> 
 findRuleUnchecked ::
                   (MonadIO m, ToJSString key) =>
                     CSSKeyframesRule -> key -> m CSSKeyframeRule
@@ -92,6 +118,15 @@
 _get_ self index = liftIO (void (js__get (self) index))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/CSSKeyframesRule._get Mozilla CSSKeyframesRule._get documentation> 
+_getUnsafe ::
+           (MonadIO m, HasCallStack) =>
+             CSSKeyframesRule -> Word -> m CSSKeyframeRule
+_getUnsafe self index
+  = liftIO
+      ((nullableToMaybe <$> (js__get (self) index)) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/CSSKeyframesRule._get Mozilla CSSKeyframesRule._get documentation> 
 _getUnchecked ::
               (MonadIO m) => CSSKeyframesRule -> Word -> m CSSKeyframeRule
 _getUnchecked self index
@@ -116,6 +151,15 @@
 getName self = liftIO (fromMaybeJSString <$> (js_getName (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/CSSKeyframesRule.name Mozilla CSSKeyframesRule.name documentation> 
+getNameUnsafe ::
+              (MonadIO m, HasCallStack, FromJSString result) =>
+                CSSKeyframesRule -> m result
+getNameUnsafe self
+  = liftIO
+      ((fromMaybeJSString <$> (js_getName (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/CSSKeyframesRule.name Mozilla CSSKeyframesRule.name documentation> 
 getNameUnchecked ::
                  (MonadIO m, FromJSString result) => CSSKeyframesRule -> m result
 getNameUnchecked self
@@ -129,6 +173,14 @@
             (MonadIO m) => CSSKeyframesRule -> m (Maybe CSSRuleList)
 getCssRules self
   = liftIO (nullableToMaybe <$> (js_getCssRules (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/CSSKeyframesRule.cssRules Mozilla CSSKeyframesRule.cssRules documentation> 
+getCssRulesUnsafe ::
+                  (MonadIO m, HasCallStack) => CSSKeyframesRule -> m CSSRuleList
+getCssRulesUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getCssRules (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/CSSKeyframesRule.cssRules Mozilla CSSKeyframesRule.cssRules documentation> 
 getCssRulesUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/CSSMediaRule.hs b/src/GHCJS/DOM/JSFFI/Generated/CSSMediaRule.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/CSSMediaRule.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/CSSMediaRule.hs
@@ -1,11 +1,17 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.CSSMediaRule
        (js_insertRule, insertRule, insertRule_, js_deleteRule, deleteRule,
-        js_getMedia, getMedia, getMediaUnchecked, js_getCssRules,
-        getCssRules, getCssRulesUnchecked, CSSMediaRule,
-        castToCSSMediaRule, gTypeCSSMediaRule)
+        js_getMedia, getMedia, getMediaUnsafe, getMediaUnchecked,
+        js_getCssRules, getCssRules, getCssRulesUnsafe,
+        getCssRulesUnchecked, CSSMediaRule(..), gTypeCSSMediaRule)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -21,6 +27,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"insertRule\"]($2, $3)"
         js_insertRule :: CSSMediaRule -> JSString -> Word -> IO Word
@@ -54,6 +70,14 @@
 getMedia self = liftIO (nullableToMaybe <$> (js_getMedia (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/CSSMediaRule.media Mozilla CSSMediaRule.media documentation> 
+getMediaUnsafe ::
+               (MonadIO m, HasCallStack) => CSSMediaRule -> m MediaList
+getMediaUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getMedia (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/CSSMediaRule.media Mozilla CSSMediaRule.media documentation> 
 getMediaUnchecked :: (MonadIO m) => CSSMediaRule -> m MediaList
 getMediaUnchecked self
   = liftIO (fromJust . nullableToMaybe <$> (js_getMedia (self)))
@@ -65,6 +89,14 @@
 getCssRules :: (MonadIO m) => CSSMediaRule -> m (Maybe CSSRuleList)
 getCssRules self
   = liftIO (nullableToMaybe <$> (js_getCssRules (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/CSSMediaRule.cssRules Mozilla CSSMediaRule.cssRules documentation> 
+getCssRulesUnsafe ::
+                  (MonadIO m, HasCallStack) => CSSMediaRule -> m CSSRuleList
+getCssRulesUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getCssRules (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/CSSMediaRule.cssRules Mozilla CSSMediaRule.cssRules documentation> 
 getCssRulesUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/CSSPageRule.hs b/src/GHCJS/DOM/JSFFI/Generated/CSSPageRule.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/CSSPageRule.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/CSSPageRule.hs
@@ -1,11 +1,17 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.CSSPageRule
        (js_setSelectorText, setSelectorText, js_getSelectorText,
-        getSelectorText, getSelectorTextUnchecked, js_getStyle, getStyle,
-        getStyleUnchecked, CSSPageRule, castToCSSPageRule,
-        gTypeCSSPageRule)
+        getSelectorText, getSelectorTextUnsafe, getSelectorTextUnchecked,
+        js_getStyle, getStyle, getStyleUnsafe, getStyleUnchecked,
+        CSSPageRule(..), gTypeCSSPageRule)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -21,6 +27,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"selectorText\"] = $2;"
         js_setSelectorText :: CSSPageRule -> Nullable JSString -> IO ()
@@ -41,6 +57,15 @@
   = liftIO (fromMaybeJSString <$> (js_getSelectorText (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/CSSPageRule.selectorText Mozilla CSSPageRule.selectorText documentation> 
+getSelectorTextUnsafe ::
+                      (MonadIO m, HasCallStack, FromJSString result) =>
+                        CSSPageRule -> m result
+getSelectorTextUnsafe self
+  = liftIO
+      ((fromMaybeJSString <$> (js_getSelectorText (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/CSSPageRule.selectorText Mozilla CSSPageRule.selectorText documentation> 
 getSelectorTextUnchecked ::
                          (MonadIO m, FromJSString result) => CSSPageRule -> m result
 getSelectorTextUnchecked self
@@ -54,6 +79,14 @@
 getStyle ::
          (MonadIO m) => CSSPageRule -> m (Maybe CSSStyleDeclaration)
 getStyle self = liftIO (nullableToMaybe <$> (js_getStyle (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/CSSPageRule.style Mozilla CSSPageRule.style documentation> 
+getStyleUnsafe ::
+               (MonadIO m, HasCallStack) => CSSPageRule -> m CSSStyleDeclaration
+getStyleUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getStyle (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/CSSPageRule.style Mozilla CSSPageRule.style documentation> 
 getStyleUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/CSSPrimitiveValue.hs b/src/GHCJS/DOM/JSFFI/Generated/CSSPrimitiveValue.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/CSSPrimitiveValue.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/CSSPrimitiveValue.hs
@@ -1,25 +1,32 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.CSSPrimitiveValue
        (js_setFloatValue, setFloatValue, js_getFloatValue, getFloatValue,
         getFloatValue_, js_setStringValue, setStringValue,
         js_getStringValue, getStringValue, getStringValue_,
         js_getCounterValue, getCounterValue, getCounterValue_,
-        getCounterValueUnchecked, js_getRectValue, getRectValue,
-        getRectValue_, getRectValueUnchecked, js_getRGBColorValue,
-        getRGBColorValue, getRGBColorValue_, getRGBColorValueUnchecked,
-        pattern CSS_UNKNOWN, pattern CSS_NUMBER, pattern CSS_PERCENTAGE,
-        pattern CSS_EMS, pattern CSS_EXS, pattern CSS_PX, pattern CSS_CM,
-        pattern CSS_MM, pattern CSS_IN, pattern CSS_PT, pattern CSS_PC,
-        pattern CSS_DEG, pattern CSS_RAD, pattern CSS_GRAD, pattern CSS_MS,
-        pattern CSS_S, pattern CSS_HZ, pattern CSS_KHZ,
-        pattern CSS_DIMENSION, pattern CSS_STRING, pattern CSS_URI,
-        pattern CSS_IDENT, pattern CSS_ATTR, pattern CSS_COUNTER,
-        pattern CSS_RECT, pattern CSS_RGBCOLOR, pattern CSS_VW,
-        pattern CSS_VH, pattern CSS_VMIN, pattern CSS_VMAX,
-        js_getPrimitiveType, getPrimitiveType, CSSPrimitiveValue,
-        castToCSSPrimitiveValue, gTypeCSSPrimitiveValue)
+        getCounterValueUnsafe, getCounterValueUnchecked, js_getRectValue,
+        getRectValue, getRectValue_, getRectValueUnsafe,
+        getRectValueUnchecked, js_getRGBColorValue, getRGBColorValue,
+        getRGBColorValue_, getRGBColorValueUnsafe,
+        getRGBColorValueUnchecked, pattern CSS_UNKNOWN, pattern CSS_NUMBER,
+        pattern CSS_PERCENTAGE, pattern CSS_EMS, pattern CSS_EXS,
+        pattern CSS_PX, pattern CSS_CM, pattern CSS_MM, pattern CSS_IN,
+        pattern CSS_PT, pattern CSS_PC, pattern CSS_DEG, pattern CSS_RAD,
+        pattern CSS_GRAD, pattern CSS_MS, pattern CSS_S, pattern CSS_HZ,
+        pattern CSS_KHZ, pattern CSS_DIMENSION, pattern CSS_STRING,
+        pattern CSS_URI, pattern CSS_IDENT, pattern CSS_ATTR,
+        pattern CSS_COUNTER, pattern CSS_RECT, pattern CSS_RGBCOLOR,
+        pattern CSS_VW, pattern CSS_VH, pattern CSS_VMIN, pattern CSS_VMAX,
+        js_getPrimitiveType, getPrimitiveType, CSSPrimitiveValue(..),
+        gTypeCSSPrimitiveValue)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -35,6 +42,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"setFloatValue\"]($2, $3)"
         js_setFloatValue :: CSSPrimitiveValue -> Word -> Float -> IO ()
@@ -97,6 +114,14 @@
 getCounterValue_ self = liftIO (void (js_getCounterValue (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/CSSPrimitiveValue.getCounterValue Mozilla CSSPrimitiveValue.getCounterValue documentation> 
+getCounterValueUnsafe ::
+                      (MonadIO m, HasCallStack) => CSSPrimitiveValue -> m Counter
+getCounterValueUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getCounterValue (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/CSSPrimitiveValue.getCounterValue Mozilla CSSPrimitiveValue.getCounterValue documentation> 
 getCounterValueUnchecked ::
                          (MonadIO m) => CSSPrimitiveValue -> m Counter
 getCounterValueUnchecked self
@@ -116,6 +141,14 @@
 getRectValue_ self = liftIO (void (js_getRectValue (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/CSSPrimitiveValue.getRectValue Mozilla CSSPrimitiveValue.getRectValue documentation> 
+getRectValueUnsafe ::
+                   (MonadIO m, HasCallStack) => CSSPrimitiveValue -> m Rect
+getRectValueUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getRectValue (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/CSSPrimitiveValue.getRectValue Mozilla CSSPrimitiveValue.getRectValue documentation> 
 getRectValueUnchecked :: (MonadIO m) => CSSPrimitiveValue -> m Rect
 getRectValueUnchecked self
   = liftIO (fromJust . nullableToMaybe <$> (js_getRectValue (self)))
@@ -132,6 +165,14 @@
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/CSSPrimitiveValue.getRGBColorValue Mozilla CSSPrimitiveValue.getRGBColorValue documentation> 
 getRGBColorValue_ :: (MonadIO m) => CSSPrimitiveValue -> m ()
 getRGBColorValue_ self = liftIO (void (js_getRGBColorValue (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/CSSPrimitiveValue.getRGBColorValue Mozilla CSSPrimitiveValue.getRGBColorValue documentation> 
+getRGBColorValueUnsafe ::
+                       (MonadIO m, HasCallStack) => CSSPrimitiveValue -> m RGBColor
+getRGBColorValueUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getRGBColorValue (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/CSSPrimitiveValue.getRGBColorValue Mozilla CSSPrimitiveValue.getRGBColorValue documentation> 
 getRGBColorValueUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/CSSRule.hs b/src/GHCJS/DOM/JSFFI/Generated/CSSRule.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/CSSRule.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/CSSRule.hs
@@ -1,4 +1,9 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.CSSRule
        (pattern UNKNOWN_RULE, pattern STYLE_RULE, pattern CHARSET_RULE,
         pattern IMPORT_RULE, pattern MEDIA_RULE, pattern FONT_FACE_RULE,
@@ -6,13 +11,15 @@
         pattern SUPPORTS_RULE, pattern WEBKIT_VIEWPORT_RULE,
         pattern WEBKIT_REGION_RULE, pattern WEBKIT_KEYFRAMES_RULE,
         pattern WEBKIT_KEYFRAME_RULE, js_getType, getType, js_setCssText,
-        setCssText, js_getCssText, getCssText, getCssTextUnchecked,
-        js_getParentStyleSheet, getParentStyleSheet,
-        getParentStyleSheetUnchecked, js_getParentRule, getParentRule,
-        getParentRuleUnchecked, CSSRule, castToCSSRule, gTypeCSSRule,
-        IsCSSRule, toCSSRule)
+        setCssText, js_getCssText, getCssText, getCssTextUnsafe,
+        getCssTextUnchecked, js_getParentStyleSheet, getParentStyleSheet,
+        getParentStyleSheetUnsafe, getParentStyleSheetUnchecked,
+        js_getParentRule, getParentRule, getParentRuleUnsafe,
+        getParentRuleUnchecked, CSSRule(..), gTypeCSSRule, IsCSSRule,
+        toCSSRule)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -28,6 +35,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
 pattern UNKNOWN_RULE = 0
 pattern STYLE_RULE = 1
 pattern CHARSET_RULE = 2
@@ -71,6 +88,15 @@
   = liftIO (fromMaybeJSString <$> (js_getCssText (toCSSRule self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/CSSRule.cssText Mozilla CSSRule.cssText documentation> 
+getCssTextUnsafe ::
+                 (MonadIO m, IsCSSRule self, HasCallStack, FromJSString result) =>
+                   self -> m result
+getCssTextUnsafe self
+  = liftIO
+      ((fromMaybeJSString <$> (js_getCssText (toCSSRule self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/CSSRule.cssText Mozilla CSSRule.cssText documentation> 
 getCssTextUnchecked ::
                     (MonadIO m, IsCSSRule self, FromJSString result) =>
                       self -> m result
@@ -89,6 +115,15 @@
       (nullableToMaybe <$> (js_getParentStyleSheet (toCSSRule self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/CSSRule.parentStyleSheet Mozilla CSSRule.parentStyleSheet documentation> 
+getParentStyleSheetUnsafe ::
+                          (MonadIO m, IsCSSRule self, HasCallStack) =>
+                            self -> m CSSStyleSheet
+getParentStyleSheetUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getParentStyleSheet (toCSSRule self)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/CSSRule.parentStyleSheet Mozilla CSSRule.parentStyleSheet documentation> 
 getParentStyleSheetUnchecked ::
                              (MonadIO m, IsCSSRule self) => self -> m CSSStyleSheet
 getParentStyleSheetUnchecked self
@@ -104,6 +139,14 @@
               (MonadIO m, IsCSSRule self) => self -> m (Maybe CSSRule)
 getParentRule self
   = liftIO (nullableToMaybe <$> (js_getParentRule (toCSSRule self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/CSSRule.parentRule Mozilla CSSRule.parentRule documentation> 
+getParentRuleUnsafe ::
+                    (MonadIO m, IsCSSRule self, HasCallStack) => self -> m CSSRule
+getParentRuleUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getParentRule (toCSSRule self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/CSSRule.parentRule Mozilla CSSRule.parentRule documentation> 
 getParentRuleUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/CSSRuleList.hs b/src/GHCJS/DOM/JSFFI/Generated/CSSRuleList.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/CSSRuleList.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/CSSRuleList.hs
@@ -1,9 +1,15 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.CSSRuleList
-       (js_item, item, item_, itemUnchecked, js_getLength, getLength,
-        CSSRuleList, castToCSSRuleList, gTypeCSSRuleList)
+       (js_item, item, item_, itemUnsafe, itemUnchecked, js_getLength,
+        getLength, CSSRuleList(..), gTypeCSSRuleList)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -19,6 +25,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"item\"]($2)" js_item ::
         CSSRuleList -> Word -> IO (Nullable CSSRule)
@@ -31,6 +47,14 @@
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/CSSRuleList.item Mozilla CSSRuleList.item documentation> 
 item_ :: (MonadIO m) => CSSRuleList -> Word -> m ()
 item_ self index = liftIO (void (js_item (self) index))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/CSSRuleList.item Mozilla CSSRuleList.item documentation> 
+itemUnsafe ::
+           (MonadIO m, HasCallStack) => CSSRuleList -> Word -> m CSSRule
+itemUnsafe self index
+  = liftIO
+      ((nullableToMaybe <$> (js_item (self) index)) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/CSSRuleList.item Mozilla CSSRuleList.item documentation> 
 itemUnchecked :: (MonadIO m) => CSSRuleList -> Word -> m CSSRule
diff --git a/src/GHCJS/DOM/JSFFI/Generated/CSSStyleDeclaration.hs b/src/GHCJS/DOM/JSFFI/Generated/CSSStyleDeclaration.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/CSSStyleDeclaration.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/CSSStyleDeclaration.hs
@@ -1,21 +1,30 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.CSSStyleDeclaration
        (js_getPropertyValue, getPropertyValue, getPropertyValue_,
-        getPropertyValueUnchecked, js_getPropertyCSSValue,
-        getPropertyCSSValue, getPropertyCSSValue_,
-        getPropertyCSSValueUnchecked, js_removeProperty, removeProperty,
-        removeProperty_, removePropertyUnchecked, js_getPropertyPriority,
-        getPropertyPriority, getPropertyPriority_,
-        getPropertyPriorityUnchecked, js_setProperty, setProperty, js_item,
-        item, item_, js_getPropertyShorthand, getPropertyShorthand,
-        getPropertyShorthand_, getPropertyShorthandUnchecked,
-        js_isPropertyImplicit, isPropertyImplicit, isPropertyImplicit_,
-        js_setCssText, setCssText, js_getCssText, getCssText,
-        getCssTextUnchecked, js_getLength, getLength, js_getParentRule,
-        getParentRule, getParentRuleUnchecked, CSSStyleDeclaration,
-        castToCSSStyleDeclaration, gTypeCSSStyleDeclaration)
+        getPropertyValueUnsafe, getPropertyValueUnchecked,
+        js_getPropertyCSSValue, getPropertyCSSValue, getPropertyCSSValue_,
+        getPropertyCSSValueUnsafe, getPropertyCSSValueUnchecked,
+        js_removeProperty, removeProperty, removeProperty_,
+        removePropertyUnsafe, removePropertyUnchecked,
+        js_getPropertyPriority, getPropertyPriority, getPropertyPriority_,
+        getPropertyPriorityUnsafe, getPropertyPriorityUnchecked,
+        js_setProperty, setProperty, js_item, item, item_,
+        js_getPropertyShorthand, getPropertyShorthand,
+        getPropertyShorthand_, getPropertyShorthandUnsafe,
+        getPropertyShorthandUnchecked, js_isPropertyImplicit,
+        isPropertyImplicit, isPropertyImplicit_, js_setCssText, setCssText,
+        js_getCssText, getCssText, getCssTextUnsafe, getCssTextUnchecked,
+        js_getLength, getLength, js_getParentRule, getParentRule,
+        getParentRuleUnsafe, getParentRuleUnchecked,
+        CSSStyleDeclaration(..), gTypeCSSStyleDeclaration)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -31,6 +40,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"getPropertyValue\"]($2)"
         js_getPropertyValue ::
@@ -54,6 +73,17 @@
       (void (js_getPropertyValue (self) (toJSString propertyName)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/CSSStyleDeclaration.getPropertyValue Mozilla CSSStyleDeclaration.getPropertyValue documentation> 
+getPropertyValueUnsafe ::
+                       (MonadIO m, ToJSString propertyName, HasCallStack,
+                        FromJSString result) =>
+                         CSSStyleDeclaration -> propertyName -> m result
+getPropertyValueUnsafe self propertyName
+  = liftIO
+      ((fromMaybeJSString <$>
+          (js_getPropertyValue (self) (toJSString propertyName)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/CSSStyleDeclaration.getPropertyValue Mozilla CSSStyleDeclaration.getPropertyValue documentation> 
 getPropertyValueUnchecked ::
                           (MonadIO m, ToJSString propertyName, FromJSString result) =>
                             CSSStyleDeclaration -> propertyName -> m result
@@ -84,6 +114,16 @@
       (void (js_getPropertyCSSValue (self) (toJSString propertyName)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/CSSStyleDeclaration.getPropertyCSSValue Mozilla CSSStyleDeclaration.getPropertyCSSValue documentation> 
+getPropertyCSSValueUnsafe ::
+                          (MonadIO m, ToJSString propertyName, HasCallStack) =>
+                            CSSStyleDeclaration -> propertyName -> m CSSValue
+getPropertyCSSValueUnsafe self propertyName
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_getPropertyCSSValue (self) (toJSString propertyName)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/CSSStyleDeclaration.getPropertyCSSValue Mozilla CSSStyleDeclaration.getPropertyCSSValue documentation> 
 getPropertyCSSValueUnchecked ::
                              (MonadIO m, ToJSString propertyName) =>
                                CSSStyleDeclaration -> propertyName -> m CSSValue
@@ -114,6 +154,17 @@
       (void (js_removeProperty (self) (toJSString propertyName)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/CSSStyleDeclaration.removeProperty Mozilla CSSStyleDeclaration.removeProperty documentation> 
+removePropertyUnsafe ::
+                     (MonadIO m, ToJSString propertyName, HasCallStack,
+                      FromJSString result) =>
+                       CSSStyleDeclaration -> propertyName -> m result
+removePropertyUnsafe self propertyName
+  = liftIO
+      ((fromMaybeJSString <$>
+          (js_removeProperty (self) (toJSString propertyName)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/CSSStyleDeclaration.removeProperty Mozilla CSSStyleDeclaration.removeProperty documentation> 
 removePropertyUnchecked ::
                         (MonadIO m, ToJSString propertyName, FromJSString result) =>
                           CSSStyleDeclaration -> propertyName -> m result
@@ -144,6 +195,17 @@
       (void (js_getPropertyPriority (self) (toJSString propertyName)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/CSSStyleDeclaration.getPropertyPriority Mozilla CSSStyleDeclaration.getPropertyPriority documentation> 
+getPropertyPriorityUnsafe ::
+                          (MonadIO m, ToJSString propertyName, HasCallStack,
+                           FromJSString result) =>
+                            CSSStyleDeclaration -> propertyName -> m result
+getPropertyPriorityUnsafe self propertyName
+  = liftIO
+      ((fromMaybeJSString <$>
+          (js_getPropertyPriority (self) (toJSString propertyName)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/CSSStyleDeclaration.getPropertyPriority Mozilla CSSStyleDeclaration.getPropertyPriority documentation> 
 getPropertyPriorityUnchecked ::
                              (MonadIO m, ToJSString propertyName, FromJSString result) =>
                                CSSStyleDeclaration -> propertyName -> m result
@@ -204,6 +266,17 @@
       (void (js_getPropertyShorthand (self) (toJSString propertyName)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/CSSStyleDeclaration.getPropertyShorthand Mozilla CSSStyleDeclaration.getPropertyShorthand documentation> 
+getPropertyShorthandUnsafe ::
+                           (MonadIO m, ToJSString propertyName, HasCallStack,
+                            FromJSString result) =>
+                             CSSStyleDeclaration -> propertyName -> m result
+getPropertyShorthandUnsafe self propertyName
+  = liftIO
+      ((fromMaybeJSString <$>
+          (js_getPropertyShorthand (self) (toJSString propertyName)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/CSSStyleDeclaration.getPropertyShorthand Mozilla CSSStyleDeclaration.getPropertyShorthand documentation> 
 getPropertyShorthandUnchecked ::
                               (MonadIO m, ToJSString propertyName, FromJSString result) =>
                                 CSSStyleDeclaration -> propertyName -> m result
@@ -252,6 +325,15 @@
   = liftIO (fromMaybeJSString <$> (js_getCssText (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/CSSStyleDeclaration.cssText Mozilla CSSStyleDeclaration.cssText documentation> 
+getCssTextUnsafe ::
+                 (MonadIO m, HasCallStack, FromJSString result) =>
+                   CSSStyleDeclaration -> m result
+getCssTextUnsafe self
+  = liftIO
+      ((fromMaybeJSString <$> (js_getCssText (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/CSSStyleDeclaration.cssText Mozilla CSSStyleDeclaration.cssText documentation> 
 getCssTextUnchecked ::
                     (MonadIO m, FromJSString result) => CSSStyleDeclaration -> m result
 getCssTextUnchecked self
@@ -272,6 +354,14 @@
               (MonadIO m) => CSSStyleDeclaration -> m (Maybe CSSRule)
 getParentRule self
   = liftIO (nullableToMaybe <$> (js_getParentRule (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/CSSStyleDeclaration.parentRule Mozilla CSSStyleDeclaration.parentRule documentation> 
+getParentRuleUnsafe ::
+                    (MonadIO m, HasCallStack) => CSSStyleDeclaration -> m CSSRule
+getParentRuleUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getParentRule (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/CSSStyleDeclaration.parentRule Mozilla CSSStyleDeclaration.parentRule documentation> 
 getParentRuleUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/CSSStyleRule.hs b/src/GHCJS/DOM/JSFFI/Generated/CSSStyleRule.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/CSSStyleRule.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/CSSStyleRule.hs
@@ -1,11 +1,17 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.CSSStyleRule
        (js_setSelectorText, setSelectorText, js_getSelectorText,
-        getSelectorText, getSelectorTextUnchecked, js_getStyle, getStyle,
-        getStyleUnchecked, CSSStyleRule, castToCSSStyleRule,
-        gTypeCSSStyleRule)
+        getSelectorText, getSelectorTextUnsafe, getSelectorTextUnchecked,
+        js_getStyle, getStyle, getStyleUnsafe, getStyleUnchecked,
+        CSSStyleRule(..), gTypeCSSStyleRule)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -21,6 +27,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"selectorText\"] = $2;"
         js_setSelectorText :: CSSStyleRule -> Nullable JSString -> IO ()
@@ -42,6 +58,15 @@
   = liftIO (fromMaybeJSString <$> (js_getSelectorText (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/CSSStyleRule.selectorText Mozilla CSSStyleRule.selectorText documentation> 
+getSelectorTextUnsafe ::
+                      (MonadIO m, HasCallStack, FromJSString result) =>
+                        CSSStyleRule -> m result
+getSelectorTextUnsafe self
+  = liftIO
+      ((fromMaybeJSString <$> (js_getSelectorText (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/CSSStyleRule.selectorText Mozilla CSSStyleRule.selectorText documentation> 
 getSelectorTextUnchecked ::
                          (MonadIO m, FromJSString result) => CSSStyleRule -> m result
 getSelectorTextUnchecked self
@@ -55,6 +80,14 @@
 getStyle ::
          (MonadIO m) => CSSStyleRule -> m (Maybe CSSStyleDeclaration)
 getStyle self = liftIO (nullableToMaybe <$> (js_getStyle (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/CSSStyleRule.style Mozilla CSSStyleRule.style documentation> 
+getStyleUnsafe ::
+               (MonadIO m, HasCallStack) => CSSStyleRule -> m CSSStyleDeclaration
+getStyleUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getStyle (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/CSSStyleRule.style Mozilla CSSStyleRule.style documentation> 
 getStyleUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/CSSStyleSheet.hs b/src/GHCJS/DOM/JSFFI/Generated/CSSStyleSheet.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/CSSStyleSheet.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/CSSStyleSheet.hs
@@ -1,13 +1,20 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.CSSStyleSheet
        (js_insertRule, insertRule, insertRule_, js_deleteRule, deleteRule,
         js_addRule, addRule, addRule_, js_removeRule, removeRule,
-        js_getOwnerRule, getOwnerRule, getOwnerRuleUnchecked,
-        js_getCssRules, getCssRules, getCssRulesUnchecked, js_getRules,
-        getRules, getRulesUnchecked, CSSStyleSheet, castToCSSStyleSheet,
+        js_getOwnerRule, getOwnerRule, getOwnerRuleUnsafe,
+        getOwnerRuleUnchecked, js_getCssRules, getCssRules,
+        getCssRulesUnsafe, getCssRulesUnchecked, js_getRules, getRules,
+        getRulesUnsafe, getRulesUnchecked, CSSStyleSheet(..),
         gTypeCSSStyleSheet)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -23,6 +30,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"insertRule\"]($2, $3)"
         js_insertRule :: CSSStyleSheet -> JSString -> Word -> IO Word
@@ -85,6 +102,14 @@
   = liftIO (nullableToMaybe <$> (js_getOwnerRule (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/CSSStyleSheet.ownerRule Mozilla CSSStyleSheet.ownerRule documentation> 
+getOwnerRuleUnsafe ::
+                   (MonadIO m, HasCallStack) => CSSStyleSheet -> m CSSRule
+getOwnerRuleUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getOwnerRule (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/CSSStyleSheet.ownerRule Mozilla CSSStyleSheet.ownerRule documentation> 
 getOwnerRuleUnchecked :: (MonadIO m) => CSSStyleSheet -> m CSSRule
 getOwnerRuleUnchecked self
   = liftIO (fromJust . nullableToMaybe <$> (js_getOwnerRule (self)))
@@ -99,6 +124,14 @@
   = liftIO (nullableToMaybe <$> (js_getCssRules (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/CSSStyleSheet.cssRules Mozilla CSSStyleSheet.cssRules documentation> 
+getCssRulesUnsafe ::
+                  (MonadIO m, HasCallStack) => CSSStyleSheet -> m CSSRuleList
+getCssRulesUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getCssRules (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/CSSStyleSheet.cssRules Mozilla CSSStyleSheet.cssRules documentation> 
 getCssRulesUnchecked ::
                      (MonadIO m) => CSSStyleSheet -> m CSSRuleList
 getCssRulesUnchecked self
@@ -110,6 +143,14 @@
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/CSSStyleSheet.rules Mozilla CSSStyleSheet.rules documentation> 
 getRules :: (MonadIO m) => CSSStyleSheet -> m (Maybe CSSRuleList)
 getRules self = liftIO (nullableToMaybe <$> (js_getRules (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/CSSStyleSheet.rules Mozilla CSSStyleSheet.rules documentation> 
+getRulesUnsafe ::
+               (MonadIO m, HasCallStack) => CSSStyleSheet -> m CSSRuleList
+getRulesUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getRules (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/CSSStyleSheet.rules Mozilla CSSStyleSheet.rules documentation> 
 getRulesUnchecked :: (MonadIO m) => CSSStyleSheet -> m CSSRuleList
diff --git a/src/GHCJS/DOM/JSFFI/Generated/CSSSupportsRule.hs b/src/GHCJS/DOM/JSFFI/Generated/CSSSupportsRule.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/CSSSupportsRule.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/CSSSupportsRule.hs
@@ -1,11 +1,17 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.CSSSupportsRule
        (js_insertRule, insertRule, insertRule_, js_deleteRule, deleteRule,
-        js_getCssRules, getCssRules, getCssRulesUnchecked,
-        js_getConditionText, getConditionText, CSSSupportsRule,
-        castToCSSSupportsRule, gTypeCSSSupportsRule)
+        js_getCssRules, getCssRules, getCssRulesUnsafe,
+        getCssRulesUnchecked, js_getConditionText, getConditionText,
+        CSSSupportsRule(..), gTypeCSSSupportsRule)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -21,6 +27,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"insertRule\"]($2, $3)"
         js_insertRule :: CSSSupportsRule -> JSString -> Word -> IO Word
@@ -54,6 +70,14 @@
             (MonadIO m) => CSSSupportsRule -> m (Maybe CSSRuleList)
 getCssRules self
   = liftIO (nullableToMaybe <$> (js_getCssRules (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/CSSSupportsRule.cssRules Mozilla CSSSupportsRule.cssRules documentation> 
+getCssRulesUnsafe ::
+                  (MonadIO m, HasCallStack) => CSSSupportsRule -> m CSSRuleList
+getCssRulesUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getCssRules (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/CSSSupportsRule.cssRules Mozilla CSSSupportsRule.cssRules documentation> 
 getCssRulesUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/CSSValue.hs b/src/GHCJS/DOM/JSFFI/Generated/CSSValue.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/CSSValue.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/CSSValue.hs
@@ -1,12 +1,18 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.CSSValue
        (pattern CSS_INHERIT, pattern CSS_PRIMITIVE_VALUE,
         pattern CSS_VALUE_LIST, pattern CSS_CUSTOM, js_setCssText,
-        setCssText, js_getCssText, getCssText, getCssTextUnchecked,
-        js_getCssValueType, getCssValueType, CSSValue, castToCSSValue,
-        gTypeCSSValue, IsCSSValue, toCSSValue)
+        setCssText, js_getCssText, getCssText, getCssTextUnsafe,
+        getCssTextUnchecked, js_getCssValueType, getCssValueType,
+        CSSValue(..), gTypeCSSValue, IsCSSValue, toCSSValue)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -22,6 +28,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
 pattern CSS_INHERIT = 0
 pattern CSS_PRIMITIVE_VALUE = 1
 pattern CSS_VALUE_LIST = 2
@@ -46,6 +62,15 @@
              self -> m (Maybe result)
 getCssText self
   = liftIO (fromMaybeJSString <$> (js_getCssText (toCSSValue self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/CSSValue.cssText Mozilla CSSValue.cssText documentation> 
+getCssTextUnsafe ::
+                 (MonadIO m, IsCSSValue self, HasCallStack, FromJSString result) =>
+                   self -> m result
+getCssTextUnsafe self
+  = liftIO
+      ((fromMaybeJSString <$> (js_getCssText (toCSSValue self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/CSSValue.cssText Mozilla CSSValue.cssText documentation> 
 getCssTextUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/CSSValueList.hs b/src/GHCJS/DOM/JSFFI/Generated/CSSValueList.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/CSSValueList.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/CSSValueList.hs
@@ -1,10 +1,16 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.CSSValueList
-       (js_item, item, item_, itemUnchecked, js_getLength, getLength,
-        CSSValueList, castToCSSValueList, gTypeCSSValueList,
-        IsCSSValueList, toCSSValueList)
+       (js_item, item, item_, itemUnsafe, itemUnchecked, js_getLength,
+        getLength, CSSValueList(..), gTypeCSSValueList, IsCSSValueList,
+        toCSSValueList)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -20,6 +26,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"item\"]($2)" js_item ::
         CSSValueList -> Word -> IO (Nullable CSSValue)
@@ -36,6 +52,15 @@
 item_ :: (MonadIO m, IsCSSValueList self) => self -> Word -> m ()
 item_ self index
   = liftIO (void (js_item (toCSSValueList self) index))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/CSSValueList.item Mozilla CSSValueList.item documentation> 
+itemUnsafe ::
+           (MonadIO m, IsCSSValueList self, HasCallStack) =>
+             self -> Word -> m CSSValue
+itemUnsafe self index
+  = liftIO
+      ((nullableToMaybe <$> (js_item (toCSSValueList self) index)) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/CSSValueList.item Mozilla CSSValueList.item documentation> 
 itemUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/CanvasGradient.hs b/src/GHCJS/DOM/JSFFI/Generated/CanvasGradient.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/CanvasGradient.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/CanvasGradient.hs
@@ -1,9 +1,15 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.CanvasGradient
-       (js_addColorStop, addColorStop, CanvasGradient,
-        castToCanvasGradient, gTypeCanvasGradient)
+       (js_addColorStop, addColorStop, CanvasGradient(..),
+        gTypeCanvasGradient)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -19,6 +25,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"addColorStop\"]($2, $3)"
         js_addColorStop :: CanvasGradient -> Float -> JSString -> IO ()
diff --git a/src/GHCJS/DOM/JSFFI/Generated/CanvasRenderingContext.hs b/src/GHCJS/DOM/JSFFI/Generated/CanvasRenderingContext.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/CanvasRenderingContext.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/CanvasRenderingContext.hs
@@ -1,11 +1,16 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.CanvasRenderingContext
-       (js_getCanvas, getCanvas, getCanvasUnchecked,
-        CanvasRenderingContext, castToCanvasRenderingContext,
-        gTypeCanvasRenderingContext, IsCanvasRenderingContext,
-        toCanvasRenderingContext)
+       (js_getCanvas, getCanvas, getCanvasUnsafe, getCanvasUnchecked,
+        CanvasRenderingContext(..), gTypeCanvasRenderingContext,
+        IsCanvasRenderingContext, toCanvasRenderingContext)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -21,6 +26,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"canvas\"]" js_getCanvas ::
         CanvasRenderingContext -> IO (Nullable HTMLCanvasElement)
@@ -33,6 +48,16 @@
   = liftIO
       (nullableToMaybe <$>
          (js_getCanvas (toCanvasRenderingContext self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/CanvasRenderingContext.canvas Mozilla CanvasRenderingContext.canvas documentation> 
+getCanvasUnsafe ::
+                (MonadIO m, IsCanvasRenderingContext self, HasCallStack) =>
+                  self -> m HTMLCanvasElement
+getCanvasUnsafe self
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_getCanvas (toCanvasRenderingContext self)))
+         >>= maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/CanvasRenderingContext.canvas Mozilla CanvasRenderingContext.canvas documentation> 
 getCanvasUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/CanvasRenderingContext2D.hs b/src/GHCJS/DOM/JSFFI/Generated/CanvasRenderingContext2D.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/CanvasRenderingContext2D.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/CanvasRenderingContext2D.hs
@@ -1,11 +1,17 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.CanvasRenderingContext2D
        (js_save, save, js_restore, restore, js_scale, scale, js_rotate,
         rotate, js_translate, translate, js_transform, transform,
         js_setTransform, setTransform, js_createLinearGradient,
         createLinearGradient, createLinearGradient_,
-        createLinearGradientUnchecked, js_createRadialGradient,
-        createRadialGradient, createRadialGradient_,
+        createLinearGradientUnsafe, createLinearGradientUnchecked,
+        js_createRadialGradient, createRadialGradient,
+        createRadialGradient_, createRadialGradientUnsafe,
         createRadialGradientUnchecked, js_setLineDash, setLineDash,
         js_getLineDash, getLineDash, getLineDash_, js_clearRect, clearRect,
         js_fillRect, fillRect, js_beginPath, beginPath, js_closePath,
@@ -18,20 +24,21 @@
         js_isPointInStrokePath, isPointInStrokePath, isPointInStrokePath_,
         js_isPointInPath, isPointInPath, isPointInPath_,
         js_isPointInStroke, isPointInStroke, isPointInStroke_,
-        js_measureText, measureText, measureText_, measureTextUnchecked,
-        js_setAlpha, setAlpha, js_setCompositeOperation,
-        setCompositeOperation, js_setLineWidthFunction,
-        setLineWidthFunction, js_setLineCapFunction, setLineCapFunction,
-        js_setLineJoinFunction, setLineJoinFunction,
-        js_setMiterLimitFunction, setMiterLimitFunction, js_clearShadow,
-        clearShadow, js_fillText, fillText, js_strokeText, strokeText,
-        js_setStrokeColor, setStrokeColor, js_setStrokeColorGray,
-        setStrokeColorGray, js_setStrokeColorRGB, setStrokeColorRGB,
-        js_setStrokeColorCYMK, setStrokeColorCYMK, js_setFillColor,
-        setFillColor, js_setFillColorGray, setFillColorGray,
-        js_setFillColorRGB, setFillColorRGB, js_setFillColorCYMK,
-        setFillColorCYMK, js_strokeRect, strokeRect, js_drawImage,
-        drawImage, js_drawImageScaled, drawImageScaled, js_drawImagePart,
+        js_measureText, measureText, measureText_, measureTextUnsafe,
+        measureTextUnchecked, js_setAlpha, setAlpha,
+        js_setCompositeOperation, setCompositeOperation,
+        js_setLineWidthFunction, setLineWidthFunction,
+        js_setLineCapFunction, setLineCapFunction, js_setLineJoinFunction,
+        setLineJoinFunction, js_setMiterLimitFunction,
+        setMiterLimitFunction, js_clearShadow, clearShadow, js_fillText,
+        fillText, js_strokeText, strokeText, js_setStrokeColor,
+        setStrokeColor, js_setStrokeColorGray, setStrokeColorGray,
+        js_setStrokeColorRGB, setStrokeColorRGB, js_setStrokeColorCYMK,
+        setStrokeColorCYMK, js_setFillColor, setFillColor,
+        js_setFillColorGray, setFillColorGray, js_setFillColorRGB,
+        setFillColorRGB, js_setFillColorCYMK, setFillColorCYMK,
+        js_strokeRect, strokeRect, js_drawImage, drawImage,
+        js_drawImageScaled, drawImageScaled, js_drawImagePart,
         drawImagePart, js_drawImageFromCanvas, drawImageFromCanvas,
         js_drawImageFromCanvasScaled, drawImageFromCanvasScaled,
         js_drawImageFromCanvasPart, drawImageFromCanvasPart,
@@ -45,32 +52,37 @@
         webkitPutImageDataHD, js_webkitPutImageDataHDDirty,
         webkitPutImageDataHDDirty, js_createPatternFromCanvas,
         createPatternFromCanvas, createPatternFromCanvas_,
-        createPatternFromCanvasUnchecked, js_createPattern, createPattern,
-        createPattern_, createPatternUnchecked, js_createImageData,
-        createImageData, createImageData_, createImageDataUnchecked,
-        js_createImageDataSize, createImageDataSize, createImageDataSize_,
-        createImageDataSizeUnchecked, js_getImageData, getImageData,
-        getImageData_, getImageDataUnchecked, js_webkitGetImageDataHD,
+        createPatternFromCanvasUnsafe, createPatternFromCanvasUnchecked,
+        js_createPattern, createPattern, createPattern_,
+        createPatternUnsafe, createPatternUnchecked, js_createImageData,
+        createImageData, createImageData_, createImageDataUnsafe,
+        createImageDataUnchecked, js_createImageDataSize,
+        createImageDataSize, createImageDataSize_,
+        createImageDataSizeUnsafe, createImageDataSizeUnchecked,
+        js_getImageData, getImageData, getImageData_, getImageDataUnsafe,
+        getImageDataUnchecked, js_webkitGetImageDataHD,
         webkitGetImageDataHD, webkitGetImageDataHD_,
-        webkitGetImageDataHDUnchecked, js_drawFocusIfNeeded,
-        drawFocusIfNeeded, js_drawFocusIfNeededPath, drawFocusIfNeededPath,
-        js_setGlobalAlpha, setGlobalAlpha, js_getGlobalAlpha,
-        getGlobalAlpha, js_setGlobalCompositeOperation,
+        webkitGetImageDataHDUnsafe, webkitGetImageDataHDUnchecked,
+        js_drawFocusIfNeeded, drawFocusIfNeeded, js_drawFocusIfNeededPath,
+        drawFocusIfNeededPath, js_setGlobalAlpha, setGlobalAlpha,
+        js_getGlobalAlpha, getGlobalAlpha, js_setGlobalCompositeOperation,
         setGlobalCompositeOperation, js_getGlobalCompositeOperation,
-        getGlobalCompositeOperation, getGlobalCompositeOperationUnchecked,
-        js_setLineWidth, setLineWidth, js_getLineWidth, getLineWidth,
-        js_setLineCap, setLineCap, js_getLineCap, getLineCap,
+        getGlobalCompositeOperation, getGlobalCompositeOperationUnsafe,
+        getGlobalCompositeOperationUnchecked, js_setLineWidth,
+        setLineWidth, js_getLineWidth, getLineWidth, js_setLineCap,
+        setLineCap, js_getLineCap, getLineCap, getLineCapUnsafe,
         getLineCapUnchecked, js_setLineJoin, setLineJoin, js_getLineJoin,
-        getLineJoin, getLineJoinUnchecked, js_setMiterLimit, setMiterLimit,
-        js_getMiterLimit, getMiterLimit, js_setShadowOffsetX,
-        setShadowOffsetX, js_getShadowOffsetX, getShadowOffsetX,
-        js_setShadowOffsetY, setShadowOffsetY, js_getShadowOffsetY,
-        getShadowOffsetY, js_setShadowBlur, setShadowBlur,
-        js_getShadowBlur, getShadowBlur, js_setShadowColor, setShadowColor,
-        js_getShadowColor, getShadowColor, getShadowColorUnchecked,
+        getLineJoin, getLineJoinUnsafe, getLineJoinUnchecked,
+        js_setMiterLimit, setMiterLimit, js_getMiterLimit, getMiterLimit,
+        js_setShadowOffsetX, setShadowOffsetX, js_getShadowOffsetX,
+        getShadowOffsetX, js_setShadowOffsetY, setShadowOffsetY,
+        js_getShadowOffsetY, getShadowOffsetY, js_setShadowBlur,
+        setShadowBlur, js_getShadowBlur, getShadowBlur, js_setShadowColor,
+        setShadowColor, js_getShadowColor, getShadowColor,
+        getShadowColorUnsafe, getShadowColorUnchecked,
         js_setLineDashOffset, setLineDashOffset, js_getLineDashOffset,
         getLineDashOffset, js_setWebkitLineDash, setWebkitLineDash,
-        js_getWebkitLineDash, getWebkitLineDash,
+        js_getWebkitLineDash, getWebkitLineDash, getWebkitLineDashUnsafe,
         getWebkitLineDashUnchecked, js_setWebkitLineDashOffset,
         setWebkitLineDashOffset, js_getWebkitLineDashOffset,
         getWebkitLineDashOffset, js_setFont, setFont, js_getFont, getFont,
@@ -78,15 +90,17 @@
         js_setTextBaseline, setTextBaseline, js_getTextBaseline,
         getTextBaseline, js_setDirection, setDirection, js_getDirection,
         getDirection, js_setStrokeStyle, setStrokeStyle, js_getStrokeStyle,
-        getStrokeStyle, getStrokeStyleUnchecked, js_setFillStyle,
-        setFillStyle, js_getFillStyle, getFillStyle, getFillStyleUnchecked,
+        getStrokeStyle, getStrokeStyleUnsafe, getStrokeStyleUnchecked,
+        js_setFillStyle, setFillStyle, js_getFillStyle, getFillStyle,
+        getFillStyleUnsafe, getFillStyleUnchecked,
         js_getWebkitBackingStorePixelRatio,
         getWebkitBackingStorePixelRatio, js_setWebkitImageSmoothingEnabled,
         setWebkitImageSmoothingEnabled, js_getWebkitImageSmoothingEnabled,
-        getWebkitImageSmoothingEnabled, CanvasRenderingContext2D,
-        castToCanvasRenderingContext2D, gTypeCanvasRenderingContext2D)
+        getWebkitImageSmoothingEnabled, CanvasRenderingContext2D(..),
+        gTypeCanvasRenderingContext2D)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -102,6 +116,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"save\"]()" js_save ::
         CanvasRenderingContext2D -> IO ()
@@ -190,6 +214,16 @@
   = liftIO (void (js_createLinearGradient (self) x0 y0 x1 y1))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/CanvasRenderingContext2D.createLinearGradient Mozilla CanvasRenderingContext2D.createLinearGradient documentation> 
+createLinearGradientUnsafe ::
+                           (MonadIO m, HasCallStack) =>
+                             CanvasRenderingContext2D ->
+                               Float -> Float -> Float -> Float -> m CanvasGradient
+createLinearGradientUnsafe self x0 y0 x1 y1
+  = liftIO
+      ((nullableToMaybe <$> (js_createLinearGradient (self) x0 y0 x1 y1))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/CanvasRenderingContext2D.createLinearGradient Mozilla CanvasRenderingContext2D.createLinearGradient documentation> 
 createLinearGradientUnchecked ::
                               (MonadIO m) =>
                                 CanvasRenderingContext2D ->
@@ -228,6 +262,18 @@
   = liftIO (void (js_createRadialGradient (self) x0 y0 r0 x1 y1 r1))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/CanvasRenderingContext2D.createRadialGradient Mozilla CanvasRenderingContext2D.createRadialGradient documentation> 
+createRadialGradientUnsafe ::
+                           (MonadIO m, HasCallStack) =>
+                             CanvasRenderingContext2D ->
+                               Float ->
+                                 Float -> Float -> Float -> Float -> Float -> m CanvasGradient
+createRadialGradientUnsafe self x0 y0 r0 x1 y1 r1
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_createRadialGradient (self) x0 y0 r0 x1 y1 r1))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/CanvasRenderingContext2D.createRadialGradient Mozilla CanvasRenderingContext2D.createRadialGradient documentation> 
 createRadialGradientUnchecked ::
                               (MonadIO m) =>
                                 CanvasRenderingContext2D ->
@@ -544,6 +590,15 @@
   = liftIO (void (js_measureText (self) (toJSString text)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/CanvasRenderingContext2D.measureText Mozilla CanvasRenderingContext2D.measureText documentation> 
+measureTextUnsafe ::
+                  (MonadIO m, ToJSString text, HasCallStack) =>
+                    CanvasRenderingContext2D -> text -> m TextMetrics
+measureTextUnsafe self text
+  = liftIO
+      ((nullableToMaybe <$> (js_measureText (self) (toJSString text)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/CanvasRenderingContext2D.measureText Mozilla CanvasRenderingContext2D.measureText documentation> 
 measureTextUnchecked ::
                      (MonadIO m, ToJSString text) =>
                        CanvasRenderingContext2D -> text -> m TextMetrics
@@ -1109,6 +1164,18 @@
             (toMaybeJSString repetitionType)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/CanvasRenderingContext2D.createPattern Mozilla CanvasRenderingContext2D.createPattern documentation> 
+createPatternFromCanvasUnsafe ::
+                              (MonadIO m, ToJSString repetitionType, HasCallStack) =>
+                                CanvasRenderingContext2D ->
+                                  Maybe HTMLCanvasElement -> Maybe repetitionType -> m CanvasPattern
+createPatternFromCanvasUnsafe self canvas repetitionType
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_createPatternFromCanvas (self) (maybeToNullable canvas)
+             (toMaybeJSString repetitionType)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/CanvasRenderingContext2D.createPattern Mozilla CanvasRenderingContext2D.createPattern documentation> 
 createPatternFromCanvasUnchecked ::
                                  (MonadIO m, ToJSString repetitionType) =>
                                    CanvasRenderingContext2D ->
@@ -1150,6 +1217,18 @@
             (toMaybeJSString repetitionType)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/CanvasRenderingContext2D.createPattern Mozilla CanvasRenderingContext2D.createPattern documentation> 
+createPatternUnsafe ::
+                    (MonadIO m, ToJSString repetitionType, HasCallStack) =>
+                      CanvasRenderingContext2D ->
+                        Maybe HTMLImageElement -> Maybe repetitionType -> m CanvasPattern
+createPatternUnsafe self image repetitionType
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_createPattern (self) (maybeToNullable image)
+             (toMaybeJSString repetitionType)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/CanvasRenderingContext2D.createPattern Mozilla CanvasRenderingContext2D.createPattern documentation> 
 createPatternUnchecked ::
                        (MonadIO m, ToJSString repetitionType) =>
                          CanvasRenderingContext2D ->
@@ -1182,6 +1261,16 @@
       (void (js_createImageData (self) (maybeToNullable imagedata)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/CanvasRenderingContext2D.createImageData Mozilla CanvasRenderingContext2D.createImageData documentation> 
+createImageDataUnsafe ::
+                      (MonadIO m, HasCallStack) =>
+                        CanvasRenderingContext2D -> Maybe ImageData -> m ImageData
+createImageDataUnsafe self imagedata
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_createImageData (self) (maybeToNullable imagedata)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/CanvasRenderingContext2D.createImageData Mozilla CanvasRenderingContext2D.createImageData documentation> 
 createImageDataUnchecked ::
                          (MonadIO m) =>
                            CanvasRenderingContext2D -> Maybe ImageData -> m ImageData
@@ -1210,6 +1299,15 @@
   = liftIO (void (js_createImageDataSize (self) sw sh))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/CanvasRenderingContext2D.createImageData Mozilla CanvasRenderingContext2D.createImageData documentation> 
+createImageDataSizeUnsafe ::
+                          (MonadIO m, HasCallStack) =>
+                            CanvasRenderingContext2D -> Float -> Float -> m ImageData
+createImageDataSizeUnsafe self sw sh
+  = liftIO
+      ((nullableToMaybe <$> (js_createImageDataSize (self) sw sh)) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/CanvasRenderingContext2D.createImageData Mozilla CanvasRenderingContext2D.createImageData documentation> 
 createImageDataSizeUnchecked ::
                              (MonadIO m) =>
                                CanvasRenderingContext2D -> Float -> Float -> m ImageData
@@ -1240,6 +1338,16 @@
   = liftIO (void (js_getImageData (self) sx sy sw sh))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/CanvasRenderingContext2D.getImageData Mozilla CanvasRenderingContext2D.getImageData documentation> 
+getImageDataUnsafe ::
+                   (MonadIO m, HasCallStack) =>
+                     CanvasRenderingContext2D ->
+                       Float -> Float -> Float -> Float -> m ImageData
+getImageDataUnsafe self sx sy sw sh
+  = liftIO
+      ((nullableToMaybe <$> (js_getImageData (self) sx sy sw sh)) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/CanvasRenderingContext2D.getImageData Mozilla CanvasRenderingContext2D.getImageData documentation> 
 getImageDataUnchecked ::
                       (MonadIO m) =>
                         CanvasRenderingContext2D ->
@@ -1273,6 +1381,16 @@
   = liftIO (void (js_webkitGetImageDataHD (self) sx sy sw sh))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/CanvasRenderingContext2D.webkitGetImageDataHD Mozilla CanvasRenderingContext2D.webkitGetImageDataHD documentation> 
+webkitGetImageDataHDUnsafe ::
+                           (MonadIO m, HasCallStack) =>
+                             CanvasRenderingContext2D ->
+                               Float -> Float -> Float -> Float -> m ImageData
+webkitGetImageDataHDUnsafe self sx sy sw sh
+  = liftIO
+      ((nullableToMaybe <$> (js_webkitGetImageDataHD (self) sx sy sw sh))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/CanvasRenderingContext2D.webkitGetImageDataHD Mozilla CanvasRenderingContext2D.webkitGetImageDataHD documentation> 
 webkitGetImageDataHDUnchecked ::
                               (MonadIO m) =>
                                 CanvasRenderingContext2D ->
@@ -1351,6 +1469,15 @@
       (fromMaybeJSString <$> (js_getGlobalCompositeOperation (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/CanvasRenderingContext2D.globalCompositeOperation Mozilla CanvasRenderingContext2D.globalCompositeOperation documentation> 
+getGlobalCompositeOperationUnsafe ::
+                                  (MonadIO m, HasCallStack, FromJSString result) =>
+                                    CanvasRenderingContext2D -> m result
+getGlobalCompositeOperationUnsafe self
+  = liftIO
+      ((fromMaybeJSString <$> (js_getGlobalCompositeOperation (self)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/CanvasRenderingContext2D.globalCompositeOperation Mozilla CanvasRenderingContext2D.globalCompositeOperation documentation> 
 getGlobalCompositeOperationUnchecked ::
                                      (MonadIO m, FromJSString result) =>
                                        CanvasRenderingContext2D -> m result
@@ -1396,6 +1523,15 @@
   = liftIO (fromMaybeJSString <$> (js_getLineCap (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/CanvasRenderingContext2D.lineCap Mozilla CanvasRenderingContext2D.lineCap documentation> 
+getLineCapUnsafe ::
+                 (MonadIO m, HasCallStack, FromJSString result) =>
+                   CanvasRenderingContext2D -> m result
+getLineCapUnsafe self
+  = liftIO
+      ((fromMaybeJSString <$> (js_getLineCap (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/CanvasRenderingContext2D.lineCap Mozilla CanvasRenderingContext2D.lineCap documentation> 
 getLineCapUnchecked ::
                     (MonadIO m, FromJSString result) =>
                       CanvasRenderingContext2D -> m result
@@ -1424,6 +1560,15 @@
   = liftIO (fromMaybeJSString <$> (js_getLineJoin (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/CanvasRenderingContext2D.lineJoin Mozilla CanvasRenderingContext2D.lineJoin documentation> 
+getLineJoinUnsafe ::
+                  (MonadIO m, HasCallStack, FromJSString result) =>
+                    CanvasRenderingContext2D -> m result
+getLineJoinUnsafe self
+  = liftIO
+      ((fromMaybeJSString <$> (js_getLineJoin (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/CanvasRenderingContext2D.lineJoin Mozilla CanvasRenderingContext2D.lineJoin documentation> 
 getLineJoinUnchecked ::
                      (MonadIO m, FromJSString result) =>
                        CanvasRenderingContext2D -> m result
@@ -1515,6 +1660,15 @@
   = liftIO (fromMaybeJSString <$> (js_getShadowColor (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/CanvasRenderingContext2D.shadowColor Mozilla CanvasRenderingContext2D.shadowColor documentation> 
+getShadowColorUnsafe ::
+                     (MonadIO m, HasCallStack, FromJSString result) =>
+                       CanvasRenderingContext2D -> m result
+getShadowColorUnsafe self
+  = liftIO
+      ((fromMaybeJSString <$> (js_getShadowColor (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/CanvasRenderingContext2D.shadowColor Mozilla CanvasRenderingContext2D.shadowColor documentation> 
 getShadowColorUnchecked ::
                         (MonadIO m, FromJSString result) =>
                           CanvasRenderingContext2D -> m result
@@ -1562,6 +1716,14 @@
   = liftIO (nullableToMaybe <$> (js_getWebkitLineDash (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/CanvasRenderingContext2D.webkitLineDash Mozilla CanvasRenderingContext2D.webkitLineDash documentation> 
+getWebkitLineDashUnsafe ::
+                        (MonadIO m, HasCallStack) => CanvasRenderingContext2D -> m Array
+getWebkitLineDashUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getWebkitLineDash (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/CanvasRenderingContext2D.webkitLineDash Mozilla CanvasRenderingContext2D.webkitLineDash documentation> 
 getWebkitLineDashUnchecked ::
                            (MonadIO m) => CanvasRenderingContext2D -> m Array
 getWebkitLineDashUnchecked self
@@ -1689,6 +1851,15 @@
   = liftIO (nullableToMaybe <$> (js_getStrokeStyle (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/CanvasRenderingContext2D.strokeStyle Mozilla CanvasRenderingContext2D.strokeStyle documentation> 
+getStrokeStyleUnsafe ::
+                     (MonadIO m, HasCallStack) =>
+                       CanvasRenderingContext2D -> m CanvasStyle
+getStrokeStyleUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getStrokeStyle (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/CanvasRenderingContext2D.strokeStyle Mozilla CanvasRenderingContext2D.strokeStyle documentation> 
 getStrokeStyleUnchecked ::
                         (MonadIO m) => CanvasRenderingContext2D -> m CanvasStyle
 getStrokeStyleUnchecked self
@@ -1716,6 +1887,15 @@
              (MonadIO m) => CanvasRenderingContext2D -> m (Maybe CanvasStyle)
 getFillStyle self
   = liftIO (nullableToMaybe <$> (js_getFillStyle (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/CanvasRenderingContext2D.fillStyle Mozilla CanvasRenderingContext2D.fillStyle documentation> 
+getFillStyleUnsafe ::
+                   (MonadIO m, HasCallStack) =>
+                     CanvasRenderingContext2D -> m CanvasStyle
+getFillStyleUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getFillStyle (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/CanvasRenderingContext2D.fillStyle Mozilla CanvasRenderingContext2D.fillStyle documentation> 
 getFillStyleUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/CapabilityRange.hs b/src/GHCJS/DOM/JSFFI/Generated/CapabilityRange.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/CapabilityRange.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/CapabilityRange.hs
@@ -1,10 +1,15 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.CapabilityRange
        (js_getMax, getMax, js_getMin, getMin, js_getSupported,
-        getSupported, CapabilityRange, castToCapabilityRange,
-        gTypeCapabilityRange)
+        getSupported, CapabilityRange(..), gTypeCapabilityRange)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -20,6 +25,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"max\"]" js_getMax ::
         CapabilityRange -> IO JSVal
diff --git a/src/GHCJS/DOM/JSFFI/Generated/CharacterData.hs b/src/GHCJS/DOM/JSFFI/Generated/CharacterData.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/CharacterData.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/CharacterData.hs
@@ -1,13 +1,20 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.CharacterData
        (js_substringData, substringData, substringData_,
-        substringDataUnchecked, js_appendData, appendData, js_insertData,
-        insertData, js_deleteData, deleteData, js_replaceData, replaceData,
-        js_setData, setData, js_getData, getData, getDataUnchecked,
-        js_getLength, getLength, CharacterData, castToCharacterData,
-        gTypeCharacterData, IsCharacterData, toCharacterData)
+        substringDataUnsafe, substringDataUnchecked, js_appendData,
+        appendData, js_insertData, insertData, js_deleteData, deleteData,
+        js_replaceData, replaceData, js_setData, setData, js_getData,
+        getData, getDataUnsafe, getDataUnchecked, js_getLength, getLength,
+        CharacterData(..), gTypeCharacterData, IsCharacterData,
+        toCharacterData)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -23,6 +30,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"substringData\"]($2, $3)"
         js_substringData ::
@@ -45,6 +62,17 @@
       (void (js_substringData (toCharacterData self) offset length))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/CharacterData.substringData Mozilla CharacterData.substringData documentation> 
+substringDataUnsafe ::
+                    (MonadIO m, IsCharacterData self, HasCallStack,
+                     FromJSString result) =>
+                      self -> Word -> Word -> m result
+substringDataUnsafe self offset length
+  = liftIO
+      ((fromMaybeJSString <$>
+          (js_substringData (toCharacterData self) offset length))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/CharacterData.substringData Mozilla CharacterData.substringData documentation> 
 substringDataUnchecked ::
                        (MonadIO m, IsCharacterData self, FromJSString result) =>
                          self -> Word -> Word -> m result
@@ -116,6 +144,16 @@
 getData self
   = liftIO
       (fromMaybeJSString <$> (js_getData (toCharacterData self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/CharacterData.data Mozilla CharacterData.data documentation> 
+getDataUnsafe ::
+              (MonadIO m, IsCharacterData self, HasCallStack,
+               FromJSString result) =>
+                self -> m result
+getDataUnsafe self
+  = liftIO
+      ((fromMaybeJSString <$> (js_getData (toCharacterData self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/CharacterData.data Mozilla CharacterData.data documentation> 
 getDataUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/ChildNode.hs b/src/GHCJS/DOM/JSFFI/Generated/ChildNode.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/ChildNode.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/ChildNode.hs
@@ -1,8 +1,13 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.ChildNode
-       (js_remove, remove, ChildNode, castToChildNode, gTypeChildNode)
-       where
+       (js_remove, remove, ChildNode(..), gTypeChildNode) where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -18,6 +23,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"remove\"]()" js_remove ::
         ChildNode -> IO ()
diff --git a/src/GHCJS/DOM/JSFFI/Generated/ClientRect.hs b/src/GHCJS/DOM/JSFFI/Generated/ClientRect.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/ClientRect.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/ClientRect.hs
@@ -1,10 +1,16 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.ClientRect
        (js_getTop, getTop, js_getRight, getRight, js_getBottom, getBottom,
         js_getLeft, getLeft, js_getWidth, getWidth, js_getHeight,
-        getHeight, ClientRect, castToClientRect, gTypeClientRect)
+        getHeight, ClientRect(..), gTypeClientRect)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -20,6 +26,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"top\"]" js_getTop ::
         ClientRect -> IO Float
diff --git a/src/GHCJS/DOM/JSFFI/Generated/ClientRectList.hs b/src/GHCJS/DOM/JSFFI/Generated/ClientRectList.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/ClientRectList.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/ClientRectList.hs
@@ -1,9 +1,15 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.ClientRectList
-       (js_item, item, item_, itemUnchecked, js_getLength, getLength,
-        ClientRectList, castToClientRectList, gTypeClientRectList)
+       (js_item, item, item_, itemUnsafe, itemUnchecked, js_getLength,
+        getLength, ClientRectList(..), gTypeClientRectList)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -19,6 +25,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"item\"]($2)" js_item ::
         ClientRectList -> Word -> IO (Nullable ClientRect)
@@ -32,6 +48,14 @@
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/ClientRectList.item Mozilla ClientRectList.item documentation> 
 item_ :: (MonadIO m) => ClientRectList -> Word -> m ()
 item_ self index = liftIO (void (js_item (self) index))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/ClientRectList.item Mozilla ClientRectList.item documentation> 
+itemUnsafe ::
+           (MonadIO m, HasCallStack) => ClientRectList -> Word -> m ClientRect
+itemUnsafe self index
+  = liftIO
+      ((nullableToMaybe <$> (js_item (self) index)) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/ClientRectList.item Mozilla ClientRectList.item documentation> 
 itemUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/CloseEvent.hs b/src/GHCJS/DOM/JSFFI/Generated/CloseEvent.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/CloseEvent.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/CloseEvent.hs
@@ -1,9 +1,15 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.CloseEvent
        (js_getWasClean, getWasClean, js_getCode, getCode, js_getReason,
-        getReason, CloseEvent, castToCloseEvent, gTypeCloseEvent)
+        getReason, CloseEvent(..), gTypeCloseEvent)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -19,6 +25,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "($1[\"wasClean\"] ? 1 : 0)"
         js_getWasClean :: CloseEvent -> IO Bool
diff --git a/src/GHCJS/DOM/JSFFI/Generated/CommandLineAPIHost.hs b/src/GHCJS/DOM/JSFFI/Generated/CommandLineAPIHost.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/CommandLineAPIHost.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/CommandLineAPIHost.hs
@@ -1,14 +1,20 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.CommandLineAPIHost
        (js_clearConsoleMessages, clearConsoleMessages, js_copyText,
         copyText, js_inspect, inspect, js_inspectedObject, inspectedObject,
         inspectedObject_, js_getEventListeners, getEventListeners,
-        getEventListeners_, getEventListenersUnchecked, js_databaseId,
-        databaseId, databaseId_, js_storageId, storageId, storageId_,
-        CommandLineAPIHost, castToCommandLineAPIHost,
+        getEventListeners_, getEventListenersUnsafe,
+        getEventListenersUnchecked, js_databaseId, databaseId, databaseId_,
+        js_storageId, storageId, storageId_, CommandLineAPIHost(..),
         gTypeCommandLineAPIHost)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -24,6 +30,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"clearConsoleMessages\"]()"
         js_clearConsoleMessages :: CommandLineAPIHost -> IO ()
@@ -84,6 +100,16 @@
   = liftIO
       (void
          (js_getEventListeners (self) (maybeToNullable (fmap toNode node))))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/CommandLineAPIHost.getEventListeners Mozilla CommandLineAPIHost.getEventListeners documentation> 
+getEventListenersUnsafe ::
+                        (MonadIO m, IsNode node, HasCallStack) =>
+                          CommandLineAPIHost -> Maybe node -> m Array
+getEventListenersUnsafe self node
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_getEventListeners (self) (maybeToNullable (fmap toNode node))))
+         >>= maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/CommandLineAPIHost.getEventListeners Mozilla CommandLineAPIHost.getEventListeners documentation> 
 getEventListenersUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/Comment.hs b/src/GHCJS/DOM/JSFFI/Generated/Comment.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/Comment.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/Comment.hs
@@ -1,8 +1,13 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.Comment
-       (js_newComment, newComment, Comment, castToComment, gTypeComment)
-       where
+       (js_newComment, newComment, Comment(..), gTypeComment) where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -18,6 +23,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "new window[\"Comment\"]($1)"
         js_newComment :: JSString -> IO Comment
diff --git a/src/GHCJS/DOM/JSFFI/Generated/CompositionEvent.hs b/src/GHCJS/DOM/JSFFI/Generated/CompositionEvent.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/CompositionEvent.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/CompositionEvent.hs
@@ -1,10 +1,15 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.CompositionEvent
        (js_initCompositionEvent, initCompositionEvent, js_getData,
-        getData, CompositionEvent, castToCompositionEvent,
-        gTypeCompositionEvent)
+        getData, CompositionEvent(..), gTypeCompositionEvent)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -20,6 +25,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe
         "$1[\"initCompositionEvent\"]($2,\n$3, $4, $5, $6)"
diff --git a/src/GHCJS/DOM/JSFFI/Generated/ConvolverNode.hs b/src/GHCJS/DOM/JSFFI/Generated/ConvolverNode.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/ConvolverNode.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/ConvolverNode.hs
@@ -1,11 +1,16 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.ConvolverNode
-       (js_setBuffer, setBuffer, js_getBuffer, getBuffer,
+       (js_setBuffer, setBuffer, js_getBuffer, getBuffer, getBufferUnsafe,
         getBufferUnchecked, js_setNormalize, setNormalize, js_getNormalize,
-        getNormalize, ConvolverNode, castToConvolverNode,
-        gTypeConvolverNode)
+        getNormalize, ConvolverNode(..), gTypeConvolverNode)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -21,6 +26,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"buffer\"] = $2;"
         js_setBuffer :: ConvolverNode -> Nullable AudioBuffer -> IO ()
@@ -37,6 +52,14 @@
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/ConvolverNode.buffer Mozilla ConvolverNode.buffer documentation> 
 getBuffer :: (MonadIO m) => ConvolverNode -> m (Maybe AudioBuffer)
 getBuffer self = liftIO (nullableToMaybe <$> (js_getBuffer (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/ConvolverNode.buffer Mozilla ConvolverNode.buffer documentation> 
+getBufferUnsafe ::
+                (MonadIO m, HasCallStack) => ConvolverNode -> m AudioBuffer
+getBufferUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getBuffer (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/ConvolverNode.buffer Mozilla ConvolverNode.buffer documentation> 
 getBufferUnchecked :: (MonadIO m) => ConvolverNode -> m AudioBuffer
diff --git a/src/GHCJS/DOM/JSFFI/Generated/Coordinates.hs b/src/GHCJS/DOM/JSFFI/Generated/Coordinates.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/Coordinates.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/Coordinates.hs
@@ -1,13 +1,21 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.Coordinates
        (js_getLatitude, getLatitude, js_getLongitude, getLongitude,
-        js_getAltitude, getAltitude, getAltitudeUnchecked, js_getAccuracy,
-        getAccuracy, js_getAltitudeAccuracy, getAltitudeAccuracy,
-        getAltitudeAccuracyUnchecked, js_getHeading, getHeading,
-        getHeadingUnchecked, js_getSpeed, getSpeed, getSpeedUnchecked,
-        Coordinates, castToCoordinates, gTypeCoordinates)
+        js_getAltitude, getAltitude, getAltitudeUnsafe,
+        getAltitudeUnchecked, js_getAccuracy, getAccuracy,
+        js_getAltitudeAccuracy, getAltitudeAccuracy,
+        getAltitudeAccuracyUnsafe, getAltitudeAccuracyUnchecked,
+        js_getHeading, getHeading, getHeadingUnsafe, getHeadingUnchecked,
+        js_getSpeed, getSpeed, getSpeedUnsafe, getSpeedUnchecked,
+        Coordinates(..), gTypeCoordinates)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -23,6 +31,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"latitude\"]" js_getLatitude
         :: Coordinates -> IO Double
@@ -47,6 +65,14 @@
   = liftIO ((js_getAltitude (self)) >>= fromJSValUnchecked)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Coordinates.altitude Mozilla Coordinates.altitude documentation> 
+getAltitudeUnsafe ::
+                  (MonadIO m, HasCallStack) => Coordinates -> m Double
+getAltitudeUnsafe self
+  = liftIO
+      (((js_getAltitude (self)) >>= fromJSValUnchecked) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Coordinates.altitude Mozilla Coordinates.altitude documentation> 
 getAltitudeUnchecked :: (MonadIO m) => Coordinates -> m Double
 getAltitudeUnchecked self
   = liftIO ((js_getAltitude (self)) >>= fromJSValUnchecked)
@@ -68,6 +94,14 @@
   = liftIO ((js_getAltitudeAccuracy (self)) >>= fromJSValUnchecked)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Coordinates.altitudeAccuracy Mozilla Coordinates.altitudeAccuracy documentation> 
+getAltitudeAccuracyUnsafe ::
+                          (MonadIO m, HasCallStack) => Coordinates -> m Double
+getAltitudeAccuracyUnsafe self
+  = liftIO
+      (((js_getAltitudeAccuracy (self)) >>= fromJSValUnchecked) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Coordinates.altitudeAccuracy Mozilla Coordinates.altitudeAccuracy documentation> 
 getAltitudeAccuracyUnchecked ::
                              (MonadIO m) => Coordinates -> m Double
 getAltitudeAccuracyUnchecked self
@@ -82,6 +116,14 @@
   = liftIO ((js_getHeading (self)) >>= fromJSValUnchecked)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Coordinates.heading Mozilla Coordinates.heading documentation> 
+getHeadingUnsafe ::
+                 (MonadIO m, HasCallStack) => Coordinates -> m Double
+getHeadingUnsafe self
+  = liftIO
+      (((js_getHeading (self)) >>= fromJSValUnchecked) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Coordinates.heading Mozilla Coordinates.heading documentation> 
 getHeadingUnchecked :: (MonadIO m) => Coordinates -> m Double
 getHeadingUnchecked self
   = liftIO ((js_getHeading (self)) >>= fromJSValUnchecked)
@@ -93,6 +135,14 @@
 getSpeed :: (MonadIO m) => Coordinates -> m (Maybe Double)
 getSpeed self
   = liftIO ((js_getSpeed (self)) >>= fromJSValUnchecked)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Coordinates.speed Mozilla Coordinates.speed documentation> 
+getSpeedUnsafe ::
+               (MonadIO m, HasCallStack) => Coordinates -> m Double
+getSpeedUnsafe self
+  = liftIO
+      (((js_getSpeed (self)) >>= fromJSValUnchecked) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Coordinates.speed Mozilla Coordinates.speed documentation> 
 getSpeedUnchecked :: (MonadIO m) => Coordinates -> m Double
diff --git a/src/GHCJS/DOM/JSFFI/Generated/Counter.hs b/src/GHCJS/DOM/JSFFI/Generated/Counter.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/Counter.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/Counter.hs
@@ -1,10 +1,15 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.Counter
        (js_getIdentifier, getIdentifier, js_getListStyle, getListStyle,
-        js_getSeparator, getSeparator, Counter, castToCounter,
-        gTypeCounter)
+        js_getSeparator, getSeparator, Counter(..), gTypeCounter)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -20,6 +25,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"identifier\"]"
         js_getIdentifier :: Counter -> IO JSString
diff --git a/src/GHCJS/DOM/JSFFI/Generated/Crypto.hs b/src/GHCJS/DOM/JSFFI/Generated/Crypto.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/Crypto.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/Crypto.hs
@@ -1,10 +1,17 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.Crypto
        (js_getRandomValues, getRandomValues, getRandomValues_,
-        getRandomValuesUnchecked, js_getWebkitSubtle, getWebkitSubtle,
-        getWebkitSubtleUnchecked, Crypto, castToCrypto, gTypeCrypto)
+        getRandomValuesUnsafe, getRandomValuesUnchecked,
+        js_getWebkitSubtle, getWebkitSubtle, getWebkitSubtleUnsafe,
+        getWebkitSubtleUnchecked, Crypto(..), gTypeCrypto)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -20,6 +27,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"getRandomValues\"]($2)"
         js_getRandomValues ::
@@ -46,6 +63,17 @@
             (maybeToNullable (fmap toArrayBufferView array))))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Crypto.getRandomValues Mozilla Crypto.getRandomValues documentation> 
+getRandomValuesUnsafe ::
+                      (MonadIO m, IsArrayBufferView array, HasCallStack) =>
+                        Crypto -> Maybe array -> m ArrayBufferView
+getRandomValuesUnsafe self array
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_getRandomValues (self)
+             (maybeToNullable (fmap toArrayBufferView array))))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Crypto.getRandomValues Mozilla Crypto.getRandomValues documentation> 
 getRandomValuesUnchecked ::
                          (MonadIO m, IsArrayBufferView array) =>
                            Crypto -> Maybe array -> m ArrayBufferView
@@ -62,6 +90,14 @@
 getWebkitSubtle :: (MonadIO m) => Crypto -> m (Maybe SubtleCrypto)
 getWebkitSubtle self
   = liftIO (nullableToMaybe <$> (js_getWebkitSubtle (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Crypto.webkitSubtle Mozilla Crypto.webkitSubtle documentation> 
+getWebkitSubtleUnsafe ::
+                      (MonadIO m, HasCallStack) => Crypto -> m SubtleCrypto
+getWebkitSubtleUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getWebkitSubtle (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Crypto.webkitSubtle Mozilla Crypto.webkitSubtle documentation> 
 getWebkitSubtleUnchecked :: (MonadIO m) => Crypto -> m SubtleCrypto
diff --git a/src/GHCJS/DOM/JSFFI/Generated/CryptoKey.hs b/src/GHCJS/DOM/JSFFI/Generated/CryptoKey.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/CryptoKey.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/CryptoKey.hs
@@ -1,10 +1,17 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.CryptoKey
        (js_getType, getType, js_getExtractable, getExtractable,
-        js_getAlgorithm, getAlgorithm, getAlgorithmUnchecked, js_getUsages,
-        getUsages, CryptoKey, castToCryptoKey, gTypeCryptoKey)
+        js_getAlgorithm, getAlgorithm, getAlgorithmUnsafe,
+        getAlgorithmUnchecked, js_getUsages, getUsages, CryptoKey(..),
+        gTypeCryptoKey)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -20,6 +27,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"type\"]" js_getType ::
         CryptoKey -> IO JSVal
@@ -42,6 +59,14 @@
 getAlgorithm :: (MonadIO m) => CryptoKey -> m (Maybe Algorithm)
 getAlgorithm self
   = liftIO (nullableToMaybe <$> (js_getAlgorithm (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/CryptoKey.algorithm Mozilla CryptoKey.algorithm documentation> 
+getAlgorithmUnsafe ::
+                   (MonadIO m, HasCallStack) => CryptoKey -> m Algorithm
+getAlgorithmUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getAlgorithm (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/CryptoKey.algorithm Mozilla CryptoKey.algorithm documentation> 
 getAlgorithmUnchecked :: (MonadIO m) => CryptoKey -> m Algorithm
diff --git a/src/GHCJS/DOM/JSFFI/Generated/CryptoKeyPair.hs b/src/GHCJS/DOM/JSFFI/Generated/CryptoKeyPair.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/CryptoKeyPair.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/CryptoKeyPair.hs
@@ -1,10 +1,17 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.CryptoKeyPair
-       (js_getPublicKey, getPublicKey, getPublicKeyUnchecked,
-        js_getPrivateKey, getPrivateKey, getPrivateKeyUnchecked,
-        CryptoKeyPair, castToCryptoKeyPair, gTypeCryptoKeyPair)
+       (js_getPublicKey, getPublicKey, getPublicKeyUnsafe,
+        getPublicKeyUnchecked, js_getPrivateKey, getPrivateKey,
+        getPrivateKeyUnsafe, getPrivateKeyUnchecked, CryptoKeyPair(..),
+        gTypeCryptoKeyPair)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -20,6 +27,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"publicKey\"]"
         js_getPublicKey :: CryptoKeyPair -> IO (Nullable CryptoKey)
@@ -30,6 +47,14 @@
   = liftIO (nullableToMaybe <$> (js_getPublicKey (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/CryptoKeyPair.publicKey Mozilla CryptoKeyPair.publicKey documentation> 
+getPublicKeyUnsafe ::
+                   (MonadIO m, HasCallStack) => CryptoKeyPair -> m CryptoKey
+getPublicKeyUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getPublicKey (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/CryptoKeyPair.publicKey Mozilla CryptoKeyPair.publicKey documentation> 
 getPublicKeyUnchecked ::
                       (MonadIO m) => CryptoKeyPair -> m CryptoKey
 getPublicKeyUnchecked self
@@ -43,6 +68,14 @@
               (MonadIO m) => CryptoKeyPair -> m (Maybe CryptoKey)
 getPrivateKey self
   = liftIO (nullableToMaybe <$> (js_getPrivateKey (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/CryptoKeyPair.privateKey Mozilla CryptoKeyPair.privateKey documentation> 
+getPrivateKeyUnsafe ::
+                    (MonadIO m, HasCallStack) => CryptoKeyPair -> m CryptoKey
+getPrivateKeyUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getPrivateKey (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/CryptoKeyPair.privateKey Mozilla CryptoKeyPair.privateKey documentation> 
 getPrivateKeyUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/CustomEvent.hs b/src/GHCJS/DOM/JSFFI/Generated/CustomEvent.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/CustomEvent.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/CustomEvent.hs
@@ -1,9 +1,15 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.CustomEvent
        (js_initCustomEvent, initCustomEvent, js_getDetail, getDetail,
-        CustomEvent, castToCustomEvent, gTypeCustomEvent)
+        CustomEvent(..), gTypeCustomEvent)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -19,6 +25,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe
         "$1[\"initCustomEvent\"]($2, $3,\n$4, $5)" js_initCustomEvent ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/DOMError.hs b/src/GHCJS/DOM/JSFFI/Generated/DOMError.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/DOMError.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/DOMError.hs
@@ -1,9 +1,15 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.DOMError
-       (js_getName, getName, DOMError, castToDOMError, gTypeDOMError,
-        IsDOMError, toDOMError)
+       (js_getName, getName, DOMError(..), gTypeDOMError, IsDOMError,
+        toDOMError)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -19,6 +25,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"name\"]" js_getName ::
         DOMError -> IO JSString
diff --git a/src/GHCJS/DOM/JSFFI/Generated/DOMImplementation.hs b/src/GHCJS/DOM/JSFFI/Generated/DOMImplementation.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/DOMImplementation.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/DOMImplementation.hs
@@ -1,16 +1,22 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.DOMImplementation
        (js_hasFeature, hasFeature, hasFeature_, js_createDocumentType,
-        createDocumentType, createDocumentType_,
+        createDocumentType, createDocumentType_, createDocumentTypeUnsafe,
         createDocumentTypeUnchecked, js_createDocument, createDocument,
-        createDocument_, createDocumentUnchecked, js_createCSSStyleSheet,
-        createCSSStyleSheet, createCSSStyleSheet_,
-        createCSSStyleSheetUnchecked, js_createHTMLDocument,
-        createHTMLDocument, createHTMLDocument_,
-        createHTMLDocumentUnchecked, DOMImplementation,
-        castToDOMImplementation, gTypeDOMImplementation)
+        createDocument_, createDocumentUnsafe, createDocumentUnchecked,
+        js_createCSSStyleSheet, createCSSStyleSheet, createCSSStyleSheet_,
+        createCSSStyleSheetUnsafe, createCSSStyleSheetUnchecked,
+        js_createHTMLDocument, createHTMLDocument, createHTMLDocument_,
+        createHTMLDocumentUnsafe, createHTMLDocumentUnchecked,
+        DOMImplementation(..), gTypeDOMImplementation)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -26,6 +32,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe
         "($1[\"hasFeature\"]($2,\n$3) ? 1 : 0)" js_hasFeature ::
@@ -85,6 +101,21 @@
             (toMaybeJSString systemId)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/DOMImplementation.createDocumentType Mozilla DOMImplementation.createDocumentType documentation> 
+createDocumentTypeUnsafe ::
+                         (MonadIO m, ToJSString qualifiedName, ToJSString publicId,
+                          ToJSString systemId, HasCallStack) =>
+                           DOMImplementation ->
+                             Maybe qualifiedName ->
+                               Maybe publicId -> Maybe systemId -> m DocumentType
+createDocumentTypeUnsafe self qualifiedName publicId systemId
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_createDocumentType (self) (toMaybeJSString qualifiedName)
+             (toMaybeJSString publicId)
+             (toMaybeJSString systemId)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/DOMImplementation.createDocumentType Mozilla DOMImplementation.createDocumentType documentation> 
 createDocumentTypeUnchecked ::
                             (MonadIO m, ToJSString qualifiedName, ToJSString publicId,
                              ToJSString systemId) =>
@@ -132,6 +163,21 @@
             (maybeToNullable doctype)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/DOMImplementation.createDocument Mozilla DOMImplementation.createDocument documentation> 
+createDocumentUnsafe ::
+                     (MonadIO m, ToJSString namespaceURI, ToJSString qualifiedName,
+                      HasCallStack) =>
+                       DOMImplementation ->
+                         Maybe namespaceURI ->
+                           Maybe qualifiedName -> Maybe DocumentType -> m Document
+createDocumentUnsafe self namespaceURI qualifiedName doctype
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_createDocument (self) (toMaybeJSString namespaceURI)
+             (toMaybeJSString qualifiedName)
+             (maybeToNullable doctype)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/DOMImplementation.createDocument Mozilla DOMImplementation.createDocument documentation> 
 createDocumentUnchecked ::
                         (MonadIO m, ToJSString namespaceURI, ToJSString qualifiedName) =>
                           DOMImplementation ->
@@ -170,6 +216,17 @@
             (toJSString media)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/DOMImplementation.createCSSStyleSheet Mozilla DOMImplementation.createCSSStyleSheet documentation> 
+createCSSStyleSheetUnsafe ::
+                          (MonadIO m, ToJSString title, ToJSString media, HasCallStack) =>
+                            DOMImplementation -> title -> media -> m CSSStyleSheet
+createCSSStyleSheetUnsafe self title media
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_createCSSStyleSheet (self) (toJSString title)
+             (toJSString media)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/DOMImplementation.createCSSStyleSheet Mozilla DOMImplementation.createCSSStyleSheet documentation> 
 createCSSStyleSheetUnchecked ::
                              (MonadIO m, ToJSString title, ToJSString media) =>
                                DOMImplementation -> title -> media -> m CSSStyleSheet
@@ -197,6 +254,16 @@
                     (MonadIO m, ToJSString title) => DOMImplementation -> title -> m ()
 createHTMLDocument_ self title
   = liftIO (void (js_createHTMLDocument (self) (toJSString title)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/DOMImplementation.createHTMLDocument Mozilla DOMImplementation.createHTMLDocument documentation> 
+createHTMLDocumentUnsafe ::
+                         (MonadIO m, ToJSString title, HasCallStack) =>
+                           DOMImplementation -> title -> m HTMLDocument
+createHTMLDocumentUnsafe self title
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_createHTMLDocument (self) (toJSString title)))
+         >>= maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/DOMImplementation.createHTMLDocument Mozilla DOMImplementation.createHTMLDocument documentation> 
 createHTMLDocumentUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/DOMNamedFlowCollection.hs b/src/GHCJS/DOM/JSFFI/Generated/DOMNamedFlowCollection.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/DOMNamedFlowCollection.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/DOMNamedFlowCollection.hs
@@ -1,11 +1,17 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.DOMNamedFlowCollection
-       (js_item, item, item_, itemUnchecked, js_namedItem, namedItem,
-        namedItem_, namedItemUnchecked, js_getLength, getLength,
-        DOMNamedFlowCollection, castToDOMNamedFlowCollection,
+       (js_item, item, item_, itemUnsafe, itemUnchecked, js_namedItem,
+        namedItem, namedItem_, namedItemUnsafe, namedItemUnchecked,
+        js_getLength, getLength, DOMNamedFlowCollection(..),
         gTypeDOMNamedFlowCollection)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -21,6 +27,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"item\"]($2)" js_item ::
         DOMNamedFlowCollection -> Word -> IO (Nullable WebKitNamedFlow)
@@ -37,6 +53,15 @@
 item_ self index = liftIO (void (js_item (self) index))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/WebKitNamedFlowCollection.item Mozilla WebKitNamedFlowCollection.item documentation> 
+itemUnsafe ::
+           (MonadIO m, HasCallStack) =>
+             DOMNamedFlowCollection -> Word -> m WebKitNamedFlow
+itemUnsafe self index
+  = liftIO
+      ((nullableToMaybe <$> (js_item (self) index)) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/WebKitNamedFlowCollection.item Mozilla WebKitNamedFlowCollection.item documentation> 
 itemUnchecked ::
               (MonadIO m) => DOMNamedFlowCollection -> Word -> m WebKitNamedFlow
 itemUnchecked self index
@@ -60,6 +85,15 @@
              DOMNamedFlowCollection -> name -> m ()
 namedItem_ self name
   = liftIO (void (js_namedItem (self) (toJSString name)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/WebKitNamedFlowCollection.namedItem Mozilla WebKitNamedFlowCollection.namedItem documentation> 
+namedItemUnsafe ::
+                (MonadIO m, ToJSString name, HasCallStack) =>
+                  DOMNamedFlowCollection -> name -> m WebKitNamedFlow
+namedItemUnsafe self name
+  = liftIO
+      ((nullableToMaybe <$> (js_namedItem (self) (toJSString name))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/WebKitNamedFlowCollection.namedItem Mozilla WebKitNamedFlowCollection.namedItem documentation> 
 namedItemUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/DOMParser.hs b/src/GHCJS/DOM/JSFFI/Generated/DOMParser.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/DOMParser.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/DOMParser.hs
@@ -1,10 +1,16 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.DOMParser
        (js_newDOMParser, newDOMParser, js_parseFromString,
-        parseFromString, parseFromString_, parseFromStringUnchecked,
-        DOMParser, castToDOMParser, gTypeDOMParser)
+        parseFromString, parseFromString_, parseFromStringUnsafe,
+        parseFromStringUnchecked, DOMParser(..), gTypeDOMParser)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -20,6 +26,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "new window[\"DOMParser\"]()"
         js_newDOMParser :: IO DOMParser
@@ -51,6 +67,18 @@
       (void
          (js_parseFromString (self) (toJSString str)
             (toJSString contentType)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/DOMParser.parseFromString Mozilla DOMParser.parseFromString documentation> 
+parseFromStringUnsafe ::
+                      (MonadIO m, ToJSString str, ToJSString contentType,
+                       HasCallStack) =>
+                        DOMParser -> str -> contentType -> m Document
+parseFromStringUnsafe self str contentType
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_parseFromString (self) (toJSString str)
+             (toJSString contentType)))
+         >>= maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/DOMParser.parseFromString Mozilla DOMParser.parseFromString documentation> 
 parseFromStringUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/DOMSettableTokenList.hs b/src/GHCJS/DOM/JSFFI/Generated/DOMSettableTokenList.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/DOMSettableTokenList.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/DOMSettableTokenList.hs
@@ -1,10 +1,16 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.DOMSettableTokenList
-       (js__get, _get, _get_, _getUnchecked, js_setValue, setValue,
-        js_getValue, getValue, DOMSettableTokenList,
-        castToDOMSettableTokenList, gTypeDOMSettableTokenList)
+       (js__get, _get, _get_, _getUnsafe, _getUnchecked, js_setValue,
+        setValue, js_getValue, getValue, DOMSettableTokenList(..),
+        gTypeDOMSettableTokenList)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -20,6 +26,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"_get\"]($2)" js__get ::
         DOMSettableTokenList -> Word -> IO (Nullable JSString)
@@ -34,6 +50,15 @@
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/DOMSettableTokenList._get Mozilla DOMSettableTokenList._get documentation> 
 _get_ :: (MonadIO m) => DOMSettableTokenList -> Word -> m ()
 _get_ self index = liftIO (void (js__get (self) index))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/DOMSettableTokenList._get Mozilla DOMSettableTokenList._get documentation> 
+_getUnsafe ::
+           (MonadIO m, HasCallStack, FromJSString result) =>
+             DOMSettableTokenList -> Word -> m result
+_getUnsafe self index
+  = liftIO
+      ((fromMaybeJSString <$> (js__get (self) index)) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/DOMSettableTokenList._get Mozilla DOMSettableTokenList._get documentation> 
 _getUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/DOMStringList.hs b/src/GHCJS/DOM/JSFFI/Generated/DOMStringList.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/DOMStringList.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/DOMStringList.hs
@@ -1,10 +1,16 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.DOMStringList
-       (js_item, item, item_, itemUnchecked, js_contains, contains,
-        contains_, js_getLength, getLength, DOMStringList,
-        castToDOMStringList, gTypeDOMStringList)
+       (js_item, item, item_, itemUnsafe, itemUnchecked, js_contains,
+        contains, contains_, js_getLength, getLength, DOMStringList(..),
+        gTypeDOMStringList)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -20,6 +26,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"item\"]($2)" js_item ::
         DOMStringList -> Word -> IO (Nullable JSString)
@@ -34,6 +50,15 @@
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/DOMStringList.item Mozilla DOMStringList.item documentation> 
 item_ :: (MonadIO m) => DOMStringList -> Word -> m ()
 item_ self index = liftIO (void (js_item (self) index))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/DOMStringList.item Mozilla DOMStringList.item documentation> 
+itemUnsafe ::
+           (MonadIO m, HasCallStack, FromJSString result) =>
+             DOMStringList -> Word -> m result
+itemUnsafe self index
+  = liftIO
+      ((fromMaybeJSString <$> (js_item (self) index)) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/DOMStringList.item Mozilla DOMStringList.item documentation> 
 itemUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/DOMTokenList.hs b/src/GHCJS/DOM/JSFFI/Generated/DOMTokenList.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/DOMTokenList.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/DOMTokenList.hs
@@ -1,12 +1,18 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.DOMTokenList
-       (js_item, item, item_, itemUnchecked, js_contains, contains,
-        contains_, js_add, add, js_remove, remove, js_toggle, toggle,
-        toggle_, js_toString, toString, toString_, js_getLength, getLength,
-        DOMTokenList, castToDOMTokenList, gTypeDOMTokenList,
-        IsDOMTokenList, toDOMTokenList)
+       (js_item, item, item_, itemUnsafe, itemUnchecked, js_contains,
+        contains, contains_, js_add, add, js_remove, remove, js_toggle,
+        toggle, toggle_, js_toString, toString, toString_, js_getLength,
+        getLength, DOMTokenList(..), gTypeDOMTokenList, IsDOMTokenList,
+        toDOMTokenList)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -22,6 +28,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"item\"]($2)" js_item ::
         DOMTokenList -> Word -> IO (Nullable JSString)
@@ -38,6 +54,16 @@
 item_ :: (MonadIO m, IsDOMTokenList self) => self -> Word -> m ()
 item_ self index
   = liftIO (void (js_item (toDOMTokenList self) index))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/DOMTokenList.item Mozilla DOMTokenList.item documentation> 
+itemUnsafe ::
+           (MonadIO m, IsDOMTokenList self, HasCallStack,
+            FromJSString result) =>
+             self -> Word -> m result
+itemUnsafe self index
+  = liftIO
+      ((fromMaybeJSString <$> (js_item (toDOMTokenList self) index)) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/DOMTokenList.item Mozilla DOMTokenList.item documentation> 
 itemUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/DataCue.hs b/src/GHCJS/DOM/JSFFI/Generated/DataCue.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/DataCue.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/DataCue.hs
@@ -1,11 +1,17 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.DataCue
        (js_newDataCue, newDataCue, js_newDataCue', newDataCue',
-        js_setData, setData, js_getData, getData, getDataUnchecked,
-        js_setValue, setValue, js_getValue, getValue, js_getType, getType,
-        DataCue, castToDataCue, gTypeDataCue)
+        js_setData, setData, js_getData, getData, getDataUnsafe,
+        getDataUnchecked, js_setValue, setValue, js_getValue, getValue,
+        js_getType, getType, DataCue(..), gTypeDataCue)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -21,6 +27,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "new window[\"WebKitDataCue\"]()"
         js_newDataCue :: IO DataCue
@@ -57,6 +73,14 @@
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/WebKitDataCue.data Mozilla WebKitDataCue.data documentation> 
 getData :: (MonadIO m) => DataCue -> m (Maybe ArrayBuffer)
 getData self = liftIO (nullableToMaybe <$> (js_getData (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/WebKitDataCue.data Mozilla WebKitDataCue.data documentation> 
+getDataUnsafe ::
+              (MonadIO m, HasCallStack) => DataCue -> m ArrayBuffer
+getDataUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getData (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/WebKitDataCue.data Mozilla WebKitDataCue.data documentation> 
 getDataUnchecked :: (MonadIO m) => DataCue -> m ArrayBuffer
diff --git a/src/GHCJS/DOM/JSFFI/Generated/DataTransfer.hs b/src/GHCJS/DOM/JSFFI/Generated/DataTransfer.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/DataTransfer.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/DataTransfer.hs
@@ -1,15 +1,21 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.DataTransfer
        (js_clearData, clearData, js_getData, getData, getData_,
         js_setData, setData, js_setDragImage, setDragImage,
         js_setDropEffect, setDropEffect, js_getDropEffect, getDropEffect,
         js_setEffectAllowed, setEffectAllowed, js_getEffectAllowed,
-        getEffectAllowed, js_getTypes, getTypes, getTypesUnchecked,
-        js_getFiles, getFiles, getFilesUnchecked, js_getItems, getItems,
-        getItemsUnchecked, DataTransfer, castToDataTransfer,
-        gTypeDataTransfer)
+        getEffectAllowed, js_getTypes, getTypes, getTypesUnsafe,
+        getTypesUnchecked, js_getFiles, getFiles, getFilesUnsafe,
+        getFilesUnchecked, js_getItems, getItems, getItemsUnsafe,
+        getItemsUnchecked, DataTransfer(..), gTypeDataTransfer)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -25,6 +31,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"clearData\"]($2)"
         js_clearData :: DataTransfer -> JSString -> IO ()
@@ -118,6 +134,14 @@
 getTypes self = liftIO (nullableToMaybe <$> (js_getTypes (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/DataTransfer.types Mozilla DataTransfer.types documentation> 
+getTypesUnsafe ::
+               (MonadIO m, HasCallStack) => DataTransfer -> m Array
+getTypesUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getTypes (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/DataTransfer.types Mozilla DataTransfer.types documentation> 
 getTypesUnchecked :: (MonadIO m) => DataTransfer -> m Array
 getTypesUnchecked self
   = liftIO (fromJust . nullableToMaybe <$> (js_getTypes (self)))
@@ -130,6 +154,14 @@
 getFiles self = liftIO (nullableToMaybe <$> (js_getFiles (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/DataTransfer.files Mozilla DataTransfer.files documentation> 
+getFilesUnsafe ::
+               (MonadIO m, HasCallStack) => DataTransfer -> m FileList
+getFilesUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getFiles (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/DataTransfer.files Mozilla DataTransfer.files documentation> 
 getFilesUnchecked :: (MonadIO m) => DataTransfer -> m FileList
 getFilesUnchecked self
   = liftIO (fromJust . nullableToMaybe <$> (js_getFiles (self)))
@@ -141,6 +173,14 @@
 getItems ::
          (MonadIO m) => DataTransfer -> m (Maybe DataTransferItemList)
 getItems self = liftIO (nullableToMaybe <$> (js_getItems (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/DataTransfer.items Mozilla DataTransfer.items documentation> 
+getItemsUnsafe ::
+               (MonadIO m, HasCallStack) => DataTransfer -> m DataTransferItemList
+getItemsUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getItems (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/DataTransfer.items Mozilla DataTransfer.items documentation> 
 getItemsUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/DataTransferItem.hs b/src/GHCJS/DOM/JSFFI/Generated/DataTransferItem.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/DataTransferItem.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/DataTransferItem.hs
@@ -1,10 +1,16 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.DataTransferItem
        (js_getAsString, getAsString, js_getAsFile, getAsFile, getAsFile_,
-        getAsFileUnchecked, js_getKind, getKind, js_getType, getType,
-        DataTransferItem, castToDataTransferItem, gTypeDataTransferItem)
+        getAsFileUnsafe, getAsFileUnchecked, js_getKind, getKind,
+        js_getType, getType, DataTransferItem(..), gTypeDataTransferItem)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -20,6 +26,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"getAsString\"]($2)"
         js_getAsString ::
@@ -42,6 +58,14 @@
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/DataTransferItem.getAsFile Mozilla DataTransferItem.getAsFile documentation> 
 getAsFile_ :: (MonadIO m) => DataTransferItem -> m ()
 getAsFile_ self = liftIO (void (js_getAsFile (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/DataTransferItem.getAsFile Mozilla DataTransferItem.getAsFile documentation> 
+getAsFileUnsafe ::
+                (MonadIO m, HasCallStack) => DataTransferItem -> m Blob
+getAsFileUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getAsFile (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/DataTransferItem.getAsFile Mozilla DataTransferItem.getAsFile documentation> 
 getAsFileUnchecked :: (MonadIO m) => DataTransferItem -> m Blob
diff --git a/src/GHCJS/DOM/JSFFI/Generated/DataTransferItemList.hs b/src/GHCJS/DOM/JSFFI/Generated/DataTransferItemList.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/DataTransferItemList.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/DataTransferItemList.hs
@@ -1,11 +1,16 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.DataTransferItemList
-       (js_item, item, item_, itemUnchecked, js_clear, clear, js_addFile,
-        addFile, js_add, add, js_getLength, getLength,
-        DataTransferItemList, castToDataTransferItemList,
-        gTypeDataTransferItemList)
+       (js_item, item, item_, itemUnsafe, itemUnchecked, js_clear, clear,
+        js_addFile, addFile, js_add, add, js_getLength, getLength,
+        DataTransferItemList(..), gTypeDataTransferItemList)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -21,6 +26,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"item\"]($2)" js_item ::
         DataTransferItemList -> Word -> IO (Nullable DataTransferItem)
@@ -35,6 +50,15 @@
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/DataTransferItemList.item Mozilla DataTransferItemList.item documentation> 
 item_ :: (MonadIO m) => DataTransferItemList -> Word -> m ()
 item_ self index = liftIO (void (js_item (self) index))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/DataTransferItemList.item Mozilla DataTransferItemList.item documentation> 
+itemUnsafe ::
+           (MonadIO m, HasCallStack) =>
+             DataTransferItemList -> Word -> m DataTransferItem
+itemUnsafe self index
+  = liftIO
+      ((nullableToMaybe <$> (js_item (self) index)) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/DataTransferItemList.item Mozilla DataTransferItemList.item documentation> 
 itemUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/Database.hs b/src/GHCJS/DOM/JSFFI/Generated/Database.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/Database.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/Database.hs
@@ -1,10 +1,16 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.Database
        (js_changeVersion, changeVersion, js_transaction, transaction,
         js_readTransaction, readTransaction, js_getVersion, getVersion,
-        Database, castToDatabase, gTypeDatabase)
+        Database(..), gTypeDatabase)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -20,6 +26,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe
         "$1[\"changeVersion\"]($2, $3, $4,\n$5, $6)" js_changeVersion ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/DatabaseCallback.hs b/src/GHCJS/DOM/JSFFI/Generated/DatabaseCallback.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/DatabaseCallback.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/DatabaseCallback.hs
@@ -1,9 +1,15 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.DatabaseCallback
        (newDatabaseCallback, newDatabaseCallbackSync,
         newDatabaseCallbackAsync, DatabaseCallback)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -19,6 +25,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/DatabaseCallback Mozilla DatabaseCallback documentation> 
 newDatabaseCallback ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/DedicatedWorkerGlobalScope.hs b/src/GHCJS/DOM/JSFFI/Generated/DedicatedWorkerGlobalScope.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/DedicatedWorkerGlobalScope.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/DedicatedWorkerGlobalScope.hs
@@ -1,9 +1,15 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.DedicatedWorkerGlobalScope
-       (js_postMessage, postMessage, message, DedicatedWorkerGlobalScope,
-        castToDedicatedWorkerGlobalScope, gTypeDedicatedWorkerGlobalScope)
+       (js_postMessage, postMessage, message,
+        DedicatedWorkerGlobalScope(..), gTypeDedicatedWorkerGlobalScope)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -19,6 +25,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"postMessage\"]($2, $3)"
         js_postMessage ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/DelayNode.hs b/src/GHCJS/DOM/JSFFI/Generated/DelayNode.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/DelayNode.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/DelayNode.hs
@@ -1,9 +1,15 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.DelayNode
-       (js_getDelayTime, getDelayTime, getDelayTimeUnchecked, DelayNode,
-        castToDelayNode, gTypeDelayNode)
+       (js_getDelayTime, getDelayTime, getDelayTimeUnsafe,
+        getDelayTimeUnchecked, DelayNode(..), gTypeDelayNode)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -19,6 +25,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"delayTime\"]"
         js_getDelayTime :: DelayNode -> IO (Nullable AudioParam)
@@ -27,6 +43,14 @@
 getDelayTime :: (MonadIO m) => DelayNode -> m (Maybe AudioParam)
 getDelayTime self
   = liftIO (nullableToMaybe <$> (js_getDelayTime (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/DelayNode.delayTime Mozilla DelayNode.delayTime documentation> 
+getDelayTimeUnsafe ::
+                   (MonadIO m, HasCallStack) => DelayNode -> m AudioParam
+getDelayTimeUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getDelayTime (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/DelayNode.delayTime Mozilla DelayNode.delayTime documentation> 
 getDelayTimeUnchecked :: (MonadIO m) => DelayNode -> m AudioParam
diff --git a/src/GHCJS/DOM/JSFFI/Generated/DeviceMotionEvent.hs b/src/GHCJS/DOM/JSFFI/Generated/DeviceMotionEvent.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/DeviceMotionEvent.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/DeviceMotionEvent.hs
@@ -1,15 +1,22 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.DeviceMotionEvent
        (js_initDeviceMotionEvent, initDeviceMotionEvent,
-        js_getAcceleration, getAcceleration, getAccelerationUnchecked,
-        js_getAccelerationIncludingGravity,
+        js_getAcceleration, getAcceleration, getAccelerationUnsafe,
+        getAccelerationUnchecked, js_getAccelerationIncludingGravity,
         getAccelerationIncludingGravity,
+        getAccelerationIncludingGravityUnsafe,
         getAccelerationIncludingGravityUnchecked, js_getRotationRate,
-        getRotationRate, getRotationRateUnchecked, js_getInterval,
-        getInterval, DeviceMotionEvent, castToDeviceMotionEvent,
+        getRotationRate, getRotationRateUnsafe, getRotationRateUnchecked,
+        js_getInterval, getInterval, DeviceMotionEvent(..),
         gTypeDeviceMotionEvent)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -25,6 +32,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe
         "$1[\"initDeviceMotionEvent\"]($2,\n$3, $4, $5, $6, $7, $8)"
@@ -70,6 +87,14 @@
   = liftIO (nullableToMaybe <$> (js_getAcceleration (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/DeviceMotionEvent.acceleration Mozilla DeviceMotionEvent.acceleration documentation> 
+getAccelerationUnsafe ::
+                      (MonadIO m, HasCallStack) => DeviceMotionEvent -> m Acceleration
+getAccelerationUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getAcceleration (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/DeviceMotionEvent.acceleration Mozilla DeviceMotionEvent.acceleration documentation> 
 getAccelerationUnchecked ::
                          (MonadIO m) => DeviceMotionEvent -> m Acceleration
 getAccelerationUnchecked self
@@ -89,6 +114,15 @@
       (nullableToMaybe <$> (js_getAccelerationIncludingGravity (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/DeviceMotionEvent.accelerationIncludingGravity Mozilla DeviceMotionEvent.accelerationIncludingGravity documentation> 
+getAccelerationIncludingGravityUnsafe ::
+                                      (MonadIO m, HasCallStack) =>
+                                        DeviceMotionEvent -> m Acceleration
+getAccelerationIncludingGravityUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getAccelerationIncludingGravity (self)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/DeviceMotionEvent.accelerationIncludingGravity Mozilla DeviceMotionEvent.accelerationIncludingGravity documentation> 
 getAccelerationIncludingGravityUnchecked ::
                                          (MonadIO m) => DeviceMotionEvent -> m Acceleration
 getAccelerationIncludingGravityUnchecked self
@@ -105,6 +139,14 @@
                 (MonadIO m) => DeviceMotionEvent -> m (Maybe RotationRate)
 getRotationRate self
   = liftIO (nullableToMaybe <$> (js_getRotationRate (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/DeviceMotionEvent.rotationRate Mozilla DeviceMotionEvent.rotationRate documentation> 
+getRotationRateUnsafe ::
+                      (MonadIO m, HasCallStack) => DeviceMotionEvent -> m RotationRate
+getRotationRateUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getRotationRate (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/DeviceMotionEvent.rotationRate Mozilla DeviceMotionEvent.rotationRate documentation> 
 getRotationRateUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/DeviceOrientationEvent.hs b/src/GHCJS/DOM/JSFFI/Generated/DeviceOrientationEvent.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/DeviceOrientationEvent.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/DeviceOrientationEvent.hs
@@ -1,11 +1,17 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.DeviceOrientationEvent
        (js_initDeviceOrientationEvent, initDeviceOrientationEvent,
         js_getAlpha, getAlpha, js_getBeta, getBeta, js_getGamma, getGamma,
-        js_getAbsolute, getAbsolute, DeviceOrientationEvent,
-        castToDeviceOrientationEvent, gTypeDeviceOrientationEvent)
+        js_getAbsolute, getAbsolute, DeviceOrientationEvent(..),
+        gTypeDeviceOrientationEvent)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -21,6 +27,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe
         "$1[\"initDeviceOrientationEvent\"]($2,\n$3, $4, $5, $6, $7, $8)"
diff --git a/src/GHCJS/DOM/JSFFI/Generated/DeviceProximityEvent.hs b/src/GHCJS/DOM/JSFFI/Generated/DeviceProximityEvent.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/DeviceProximityEvent.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/DeviceProximityEvent.hs
@@ -1,10 +1,15 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.DeviceProximityEvent
        (js_getValue, getValue, js_getMin, getMin, js_getMax, getMax,
-        DeviceProximityEvent, castToDeviceProximityEvent,
-        gTypeDeviceProximityEvent)
+        DeviceProximityEvent(..), gTypeDeviceProximityEvent)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -20,6 +25,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"value\"]" js_getValue ::
         DeviceProximityEvent -> IO Double
diff --git a/src/GHCJS/DOM/JSFFI/Generated/Document.hs b/src/GHCJS/DOM/JSFFI/Generated/Document.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/Document.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/Document.hs
@@ -1,109 +1,141 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.Document
        (js_newDocument, newDocument, js_createElement, createElement,
-        createElement_, createElementUnchecked, js_createDocumentFragment,
-        createDocumentFragment, createDocumentFragment_,
+        createElement_, createElementUnsafe, createElementUnchecked,
+        js_createDocumentFragment, createDocumentFragment,
+        createDocumentFragment_, createDocumentFragmentUnsafe,
         createDocumentFragmentUnchecked, js_createTextNode, createTextNode,
-        createTextNode_, createTextNodeUnchecked, js_createComment,
-        createComment, createComment_, createCommentUnchecked,
-        js_createCDATASection, createCDATASection, createCDATASection_,
+        createTextNode_, createTextNodeUnsafe, createTextNodeUnchecked,
+        js_createComment, createComment, createComment_,
+        createCommentUnsafe, createCommentUnchecked, js_createCDATASection,
+        createCDATASection, createCDATASection_, createCDATASectionUnsafe,
         createCDATASectionUnchecked, js_createProcessingInstruction,
         createProcessingInstruction, createProcessingInstruction_,
+        createProcessingInstructionUnsafe,
         createProcessingInstructionUnchecked, js_createAttribute,
-        createAttribute, createAttribute_, createAttributeUnchecked,
-        js_createEntityReference, createEntityReference,
-        createEntityReference_, createEntityReferenceUnchecked,
+        createAttribute, createAttribute_, createAttributeUnsafe,
+        createAttributeUnchecked, js_createEntityReference,
+        createEntityReference, createEntityReference_,
+        createEntityReferenceUnsafe, createEntityReferenceUnchecked,
         js_getElementsByTagName, getElementsByTagName,
-        getElementsByTagName_, getElementsByTagNameUnchecked,
-        js_importNode, importNode, importNode_, importNodeUnchecked,
+        getElementsByTagName_, getElementsByTagNameUnsafe,
+        getElementsByTagNameUnchecked, js_importNode, importNode,
+        importNode_, importNodeUnsafe, importNodeUnchecked,
         js_createElementNS, createElementNS, createElementNS_,
-        createElementNSUnchecked, js_createAttributeNS, createAttributeNS,
-        createAttributeNS_, createAttributeNSUnchecked,
+        createElementNSUnsafe, createElementNSUnchecked,
+        js_createAttributeNS, createAttributeNS, createAttributeNS_,
+        createAttributeNSUnsafe, createAttributeNSUnchecked,
         js_getElementsByTagNameNS, getElementsByTagNameNS,
-        getElementsByTagNameNS_, getElementsByTagNameNSUnchecked,
-        js_getElementById, getElementById, getElementById_,
-        getElementByIdUnchecked, js_adoptNode, adoptNode, adoptNode_,
+        getElementsByTagNameNS_, getElementsByTagNameNSUnsafe,
+        getElementsByTagNameNSUnchecked, js_getElementById, getElementById,
+        getElementById_, getElementByIdUnsafe, getElementByIdUnchecked,
+        js_adoptNode, adoptNode, adoptNode_, adoptNodeUnsafe,
         adoptNodeUnchecked, js_createEvent, createEvent, createEvent_,
-        createEventUnchecked, js_createRange, createRange, createRange_,
-        createRangeUnchecked, js_createNodeIterator, createNodeIterator,
-        createNodeIterator_, createNodeIteratorUnchecked,
+        createEventUnsafe, createEventUnchecked, js_createRange,
+        createRange, createRange_, createRangeUnsafe, createRangeUnchecked,
+        js_createNodeIterator, createNodeIterator, createNodeIterator_,
+        createNodeIteratorUnsafe, createNodeIteratorUnchecked,
         js_createTreeWalker, createTreeWalker, createTreeWalker_,
-        createTreeWalkerUnchecked, js_getOverrideStyle, getOverrideStyle,
-        getOverrideStyle_, getOverrideStyleUnchecked, js_createExpression,
-        createExpression, createExpression_, createExpressionUnchecked,
+        createTreeWalkerUnsafe, createTreeWalkerUnchecked,
+        js_getOverrideStyle, getOverrideStyle, getOverrideStyle_,
+        getOverrideStyleUnsafe, getOverrideStyleUnchecked,
+        js_createExpression, createExpression, createExpression_,
+        createExpressionUnsafe, createExpressionUnchecked,
         js_createNSResolver, createNSResolver, createNSResolver_,
-        createNSResolverUnchecked, js_evaluate, evaluate, evaluate_,
-        evaluateUnchecked, js_execCommand, execCommand, execCommand_,
-        js_queryCommandEnabled, queryCommandEnabled, queryCommandEnabled_,
-        js_queryCommandIndeterm, queryCommandIndeterm,
-        queryCommandIndeterm_, js_queryCommandState, queryCommandState,
-        queryCommandState_, js_queryCommandSupported,
+        createNSResolverUnsafe, createNSResolverUnchecked, js_evaluate,
+        evaluate, evaluate_, evaluateUnsafe, evaluateUnchecked,
+        js_execCommand, execCommand, execCommand_, js_queryCommandEnabled,
+        queryCommandEnabled, queryCommandEnabled_, js_queryCommandIndeterm,
+        queryCommandIndeterm, queryCommandIndeterm_, js_queryCommandState,
+        queryCommandState, queryCommandState_, js_queryCommandSupported,
         queryCommandSupported, queryCommandSupported_,
         js_queryCommandValue, queryCommandValue, queryCommandValue_,
         js_getElementsByName, getElementsByName, getElementsByName_,
-        getElementsByNameUnchecked, js_elementFromPoint, elementFromPoint,
-        elementFromPoint_, elementFromPointUnchecked,
+        getElementsByNameUnsafe, getElementsByNameUnchecked,
+        js_elementFromPoint, elementFromPoint, elementFromPoint_,
+        elementFromPointUnsafe, elementFromPointUnchecked,
         js_caretRangeFromPoint, caretRangeFromPoint, caretRangeFromPoint_,
-        caretRangeFromPointUnchecked, js_getSelection, getSelection,
-        getSelection_, getSelectionUnchecked, js_getCSSCanvasContext,
-        getCSSCanvasContext, getCSSCanvasContext_,
+        caretRangeFromPointUnsafe, caretRangeFromPointUnchecked,
+        js_getSelection, getSelection, getSelection_, getSelectionUnsafe,
+        getSelectionUnchecked, js_getCSSCanvasContext, getCSSCanvasContext,
+        getCSSCanvasContext_, getCSSCanvasContextUnsafe,
         getCSSCanvasContextUnchecked, js_getElementsByClassName,
         getElementsByClassName, getElementsByClassName_,
-        getElementsByClassNameUnchecked, js_hasFocus, hasFocus, hasFocus_,
-        js_querySelector, querySelector, querySelector_,
-        querySelectorUnchecked, js_querySelectorAll, querySelectorAll,
-        querySelectorAll_, querySelectorAllUnchecked,
+        getElementsByClassNameUnsafe, getElementsByClassNameUnchecked,
+        js_hasFocus, hasFocus, hasFocus_, js_querySelector, querySelector,
+        querySelector_, querySelectorUnsafe, querySelectorUnchecked,
+        js_querySelectorAll, querySelectorAll, querySelectorAll_,
+        querySelectorAllUnsafe, querySelectorAllUnchecked,
         js_webkitCancelFullScreen, webkitCancelFullScreen,
         js_webkitExitFullscreen, webkitExitFullscreen, js_exitPointerLock,
         exitPointerLock, js_webkitGetNamedFlows, webkitGetNamedFlows,
-        webkitGetNamedFlows_, webkitGetNamedFlowsUnchecked, js_createTouch,
-        createTouch, createTouch_, createTouchUnchecked,
+        webkitGetNamedFlows_, webkitGetNamedFlowsUnsafe,
+        webkitGetNamedFlowsUnchecked, js_createTouch, createTouch,
+        createTouch_, createTouchUnsafe, createTouchUnchecked,
         js_createTouchList, createTouchList, createTouchList_,
-        createTouchListUnchecked, js_getDoctype, getDoctype,
-        getDoctypeUnchecked, js_getImplementation, getImplementation,
+        createTouchListUnsafe, createTouchListUnchecked, js_getDoctype,
+        getDoctype, getDoctypeUnsafe, getDoctypeUnchecked,
+        js_getImplementation, getImplementation, getImplementationUnsafe,
         getImplementationUnchecked, js_getDocumentElement,
-        getDocumentElement, getDocumentElementUnchecked,
-        js_getInputEncoding, getInputEncoding, getInputEncodingUnchecked,
-        js_getXmlEncoding, getXmlEncoding, getXmlEncodingUnchecked,
-        js_setXmlVersion, setXmlVersion, js_getXmlVersion, getXmlVersion,
+        getDocumentElement, getDocumentElementUnsafe,
+        getDocumentElementUnchecked, js_getInputEncoding, getInputEncoding,
+        getInputEncodingUnsafe, getInputEncodingUnchecked,
+        js_getXmlEncoding, getXmlEncoding, getXmlEncodingUnsafe,
+        getXmlEncodingUnchecked, js_setXmlVersion, setXmlVersion,
+        js_getXmlVersion, getXmlVersion, getXmlVersionUnsafe,
         getXmlVersionUnchecked, js_setXmlStandalone, setXmlStandalone,
         js_getXmlStandalone, getXmlStandalone, js_getDocumentURI,
-        getDocumentURI, getDocumentURIUnchecked, js_getDefaultView,
-        getDefaultView, getDefaultViewUnchecked, js_getStyleSheets,
-        getStyleSheets, getStyleSheetsUnchecked, js_getContentType,
+        getDocumentURI, getDocumentURIUnsafe, getDocumentURIUnchecked,
+        js_getDefaultView, getDefaultView, getDefaultViewUnsafe,
+        getDefaultViewUnchecked, js_getStyleSheets, getStyleSheets,
+        getStyleSheetsUnsafe, getStyleSheetsUnchecked, js_getContentType,
         getContentType, js_setTitle, setTitle, js_getTitle, getTitle,
-        getTitleUnchecked, js_getReferrer, getReferrer, js_setDomain,
-        setDomain, js_getDomain, getDomain, getDomainUnchecked, js_getURL,
-        getURL, js_setCookie, setCookie, js_getCookie, getCookie,
-        getCookieUnchecked, js_setBody, setBody, js_getBody, getBody,
-        getBodyUnchecked, js_getHead, getHead, getHeadUnchecked,
-        js_getImages, getImages, getImagesUnchecked, js_getApplets,
-        getApplets, getAppletsUnchecked, js_getLinks, getLinks,
-        getLinksUnchecked, js_getForms, getForms, getFormsUnchecked,
-        js_getAnchors, getAnchors, getAnchorsUnchecked, js_getLastModified,
-        getLastModified, js_setLocation, setLocation, js_getLocation,
-        getLocation, getLocationUnchecked, js_setCharset, setCharset,
-        js_getCharset, getCharset, getCharsetUnchecked,
-        js_getDefaultCharset, getDefaultCharset,
+        getTitleUnsafe, getTitleUnchecked, js_getReferrer, getReferrer,
+        js_setDomain, setDomain, js_getDomain, getDomain, getDomainUnsafe,
+        getDomainUnchecked, js_getURL, getURL, js_setCookie, setCookie,
+        js_getCookie, getCookie, getCookieUnsafe, getCookieUnchecked,
+        js_setBody, setBody, js_getBody, getBody, getBodyUnsafe,
+        getBodyUnchecked, js_getHead, getHead, getHeadUnsafe,
+        getHeadUnchecked, js_getImages, getImages, getImagesUnsafe,
+        getImagesUnchecked, js_getApplets, getApplets, getAppletsUnsafe,
+        getAppletsUnchecked, js_getLinks, getLinks, getLinksUnsafe,
+        getLinksUnchecked, js_getForms, getForms, getFormsUnsafe,
+        getFormsUnchecked, js_getAnchors, getAnchors, getAnchorsUnsafe,
+        getAnchorsUnchecked, js_getLastModified, getLastModified,
+        js_setLocation, setLocation, js_getLocation, getLocation,
+        getLocationUnsafe, getLocationUnchecked, js_setCharset, setCharset,
+        js_getCharset, getCharset, getCharsetUnsafe, getCharsetUnchecked,
+        js_getDefaultCharset, getDefaultCharset, getDefaultCharsetUnsafe,
         getDefaultCharsetUnchecked, js_getReadyState, getReadyState,
-        getReadyStateUnchecked, js_getCharacterSet, getCharacterSet,
-        getCharacterSetUnchecked, js_getPreferredStylesheetSet,
-        getPreferredStylesheetSet, getPreferredStylesheetSetUnchecked,
-        js_setSelectedStylesheetSet, setSelectedStylesheetSet,
-        js_getSelectedStylesheetSet, getSelectedStylesheetSet,
+        getReadyStateUnsafe, getReadyStateUnchecked, js_getCharacterSet,
+        getCharacterSet, getCharacterSetUnsafe, getCharacterSetUnchecked,
+        js_getPreferredStylesheetSet, getPreferredStylesheetSet,
+        getPreferredStylesheetSetUnsafe,
+        getPreferredStylesheetSetUnchecked, js_setSelectedStylesheetSet,
+        setSelectedStylesheetSet, js_getSelectedStylesheetSet,
+        getSelectedStylesheetSet, getSelectedStylesheetSetUnsafe,
         getSelectedStylesheetSetUnchecked, js_getActiveElement,
-        getActiveElement, getActiveElementUnchecked, js_getCompatMode,
-        getCompatMode, js_getWebkitIsFullScreen, getWebkitIsFullScreen,
+        getActiveElement, getActiveElementUnsafe,
+        getActiveElementUnchecked, js_getCompatMode, getCompatMode,
+        js_getWebkitIsFullScreen, getWebkitIsFullScreen,
         js_getWebkitFullScreenKeyboardInputAllowed,
         getWebkitFullScreenKeyboardInputAllowed,
         js_getWebkitCurrentFullScreenElement,
         getWebkitCurrentFullScreenElement,
+        getWebkitCurrentFullScreenElementUnsafe,
         getWebkitCurrentFullScreenElementUnchecked,
         js_getWebkitFullscreenEnabled, getWebkitFullscreenEnabled,
         js_getWebkitFullscreenElement, getWebkitFullscreenElement,
+        getWebkitFullscreenElementUnsafe,
         getWebkitFullscreenElementUnchecked, js_getPointerLockElement,
-        getPointerLockElement, getPointerLockElementUnchecked, js_getFonts,
-        getFonts, getFontsUnchecked, abort, blur, change, click,
+        getPointerLockElement, getPointerLockElementUnsafe,
+        getPointerLockElementUnchecked, js_getFonts, getFonts,
+        getFontsUnsafe, getFontsUnchecked, abort, blur, change, click,
         contextMenu, dblClick, drag, dragEnd, dragEnter, dragLeave,
         dragOver, dragStart, drop, error, focus, input, invalid, keyDown,
         keyPress, keyUp, load, mouseDown, mouseEnter, mouseLeave,
@@ -115,12 +147,13 @@
         pointerlockerror, securitypolicyviolation, webKitWillRevealBottom,
         webKitWillRevealLeft, webKitWillRevealRight, webKitWillRevealTop,
         js_getVisibilityState, getVisibilityState, js_getHidden, getHidden,
-        js_getSecurityPolicy, getSecurityPolicy,
+        js_getSecurityPolicy, getSecurityPolicy, getSecurityPolicyUnsafe,
         getSecurityPolicyUnchecked, js_getCurrentScript, getCurrentScript,
-        getCurrentScriptUnchecked, js_getOrigin, getOrigin, Document,
-        castToDocument, gTypeDocument, IsDocument, toDocument)
+        getCurrentScriptUnsafe, getCurrentScriptUnchecked, js_getOrigin,
+        getOrigin, Document(..), gTypeDocument, IsDocument, toDocument)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -136,6 +169,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "new window[\"Document\"]()"
         js_newDocument :: IO Document
@@ -167,6 +210,16 @@
          (js_createElement (toDocument self) (toMaybeJSString tagName)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.createElement Mozilla Document.createElement documentation> 
+createElementUnsafe ::
+                    (MonadIO m, IsDocument self, ToJSString tagName, HasCallStack) =>
+                      self -> Maybe tagName -> m Element
+createElementUnsafe self tagName
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_createElement (toDocument self) (toMaybeJSString tagName)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.createElement Mozilla Document.createElement documentation> 
 createElementUnchecked ::
                        (MonadIO m, IsDocument self, ToJSString tagName) =>
                          self -> Maybe tagName -> m Element
@@ -193,6 +246,16 @@
   = liftIO (void (js_createDocumentFragment (toDocument self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.createDocumentFragment Mozilla Document.createDocumentFragment documentation> 
+createDocumentFragmentUnsafe ::
+                             (MonadIO m, IsDocument self, HasCallStack) =>
+                               self -> m DocumentFragment
+createDocumentFragmentUnsafe self
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_createDocumentFragment (toDocument self)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.createDocumentFragment Mozilla Document.createDocumentFragment documentation> 
 createDocumentFragmentUnchecked ::
                                 (MonadIO m, IsDocument self) => self -> m DocumentFragment
 createDocumentFragmentUnchecked self
@@ -221,6 +284,16 @@
       (void (js_createTextNode (toDocument self) (toJSString data')))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.createTextNode Mozilla Document.createTextNode documentation> 
+createTextNodeUnsafe ::
+                     (MonadIO m, IsDocument self, ToJSString data', HasCallStack) =>
+                       self -> data' -> m Text
+createTextNodeUnsafe self data'
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_createTextNode (toDocument self) (toJSString data')))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.createTextNode Mozilla Document.createTextNode documentation> 
 createTextNodeUnchecked ::
                         (MonadIO m, IsDocument self, ToJSString data') =>
                           self -> data' -> m Text
@@ -250,6 +323,16 @@
       (void (js_createComment (toDocument self) (toJSString data')))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.createComment Mozilla Document.createComment documentation> 
+createCommentUnsafe ::
+                    (MonadIO m, IsDocument self, ToJSString data', HasCallStack) =>
+                      self -> data' -> m Comment
+createCommentUnsafe self data'
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_createComment (toDocument self) (toJSString data')))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.createComment Mozilla Document.createComment documentation> 
 createCommentUnchecked ::
                        (MonadIO m, IsDocument self, ToJSString data') =>
                          self -> data' -> m Comment
@@ -280,6 +363,16 @@
       (void (js_createCDATASection (toDocument self) (toJSString data')))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.createCDATASection Mozilla Document.createCDATASection documentation> 
+createCDATASectionUnsafe ::
+                         (MonadIO m, IsDocument self, ToJSString data', HasCallStack) =>
+                           self -> data' -> m CDATASection
+createCDATASectionUnsafe self data'
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_createCDATASection (toDocument self) (toJSString data')))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.createCDATASection Mozilla Document.createCDATASection documentation> 
 createCDATASectionUnchecked ::
                             (MonadIO m, IsDocument self, ToJSString data') =>
                               self -> data' -> m CDATASection
@@ -319,6 +412,19 @@
             (toJSString data')))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.createProcessingInstruction Mozilla Document.createProcessingInstruction documentation> 
+createProcessingInstructionUnsafe ::
+                                  (MonadIO m, IsDocument self, ToJSString target, ToJSString data',
+                                   HasCallStack) =>
+                                    self -> target -> data' -> m ProcessingInstruction
+createProcessingInstructionUnsafe self target data'
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_createProcessingInstruction (toDocument self)
+             (toJSString target)
+             (toJSString data')))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.createProcessingInstruction Mozilla Document.createProcessingInstruction documentation> 
 createProcessingInstructionUnchecked ::
                                      (MonadIO m, IsDocument self, ToJSString target,
                                       ToJSString data') =>
@@ -351,6 +457,16 @@
       (void (js_createAttribute (toDocument self) (toJSString name)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.createAttribute Mozilla Document.createAttribute documentation> 
+createAttributeUnsafe ::
+                      (MonadIO m, IsDocument self, ToJSString name, HasCallStack) =>
+                        self -> name -> m Attr
+createAttributeUnsafe self name
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_createAttribute (toDocument self) (toJSString name)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.createAttribute Mozilla Document.createAttribute documentation> 
 createAttributeUnchecked ::
                          (MonadIO m, IsDocument self, ToJSString name) =>
                            self -> name -> m Attr
@@ -382,6 +498,16 @@
          (js_createEntityReference (toDocument self) (toJSString name)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.createEntityReference Mozilla Document.createEntityReference documentation> 
+createEntityReferenceUnsafe ::
+                            (MonadIO m, IsDocument self, ToJSString name, HasCallStack) =>
+                              self -> name -> m EntityReference
+createEntityReferenceUnsafe self name
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_createEntityReference (toDocument self) (toJSString name)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.createEntityReference Mozilla Document.createEntityReference documentation> 
 createEntityReferenceUnchecked ::
                                (MonadIO m, IsDocument self, ToJSString name) =>
                                  self -> name -> m EntityReference
@@ -413,6 +539,16 @@
          (js_getElementsByTagName (toDocument self) (toJSString tagname)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.getElementsByTagName Mozilla Document.getElementsByTagName documentation> 
+getElementsByTagNameUnsafe ::
+                           (MonadIO m, IsDocument self, ToJSString tagname, HasCallStack) =>
+                             self -> tagname -> m NodeList
+getElementsByTagNameUnsafe self tagname
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_getElementsByTagName (toDocument self) (toJSString tagname)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.getElementsByTagName Mozilla Document.getElementsByTagName documentation> 
 getElementsByTagNameUnchecked ::
                               (MonadIO m, IsDocument self, ToJSString tagname) =>
                                 self -> tagname -> m NodeList
@@ -448,6 +584,18 @@
             deep))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.importNode Mozilla Document.importNode documentation> 
+importNodeUnsafe ::
+                 (MonadIO m, IsDocument self, IsNode importedNode, HasCallStack) =>
+                   self -> Maybe importedNode -> Bool -> m Node
+importNodeUnsafe self importedNode deep
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_importNode (toDocument self)
+             (maybeToNullable (fmap toNode importedNode))
+             deep))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.importNode Mozilla Document.importNode documentation> 
 importNodeUnchecked ::
                     (MonadIO m, IsDocument self, IsNode importedNode) =>
                       self -> Maybe importedNode -> Bool -> m Node
@@ -489,6 +637,19 @@
             (toMaybeJSString qualifiedName)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.createElementNS Mozilla Document.createElementNS documentation> 
+createElementNSUnsafe ::
+                      (MonadIO m, IsDocument self, ToJSString namespaceURI,
+                       ToJSString qualifiedName, HasCallStack) =>
+                        self -> Maybe namespaceURI -> Maybe qualifiedName -> m Element
+createElementNSUnsafe self namespaceURI qualifiedName
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_createElementNS (toDocument self)
+             (toMaybeJSString namespaceURI)
+             (toMaybeJSString qualifiedName)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.createElementNS Mozilla Document.createElementNS documentation> 
 createElementNSUnchecked ::
                          (MonadIO m, IsDocument self, ToJSString namespaceURI,
                           ToJSString qualifiedName) =>
@@ -530,6 +691,19 @@
             (toMaybeJSString qualifiedName)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.createAttributeNS Mozilla Document.createAttributeNS documentation> 
+createAttributeNSUnsafe ::
+                        (MonadIO m, IsDocument self, ToJSString namespaceURI,
+                         ToJSString qualifiedName, HasCallStack) =>
+                          self -> Maybe namespaceURI -> Maybe qualifiedName -> m Attr
+createAttributeNSUnsafe self namespaceURI qualifiedName
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_createAttributeNS (toDocument self)
+             (toMaybeJSString namespaceURI)
+             (toMaybeJSString qualifiedName)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.createAttributeNS Mozilla Document.createAttributeNS documentation> 
 createAttributeNSUnchecked ::
                            (MonadIO m, IsDocument self, ToJSString namespaceURI,
                             ToJSString qualifiedName) =>
@@ -571,6 +745,19 @@
             (toJSString localName)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.getElementsByTagNameNS Mozilla Document.getElementsByTagNameNS documentation> 
+getElementsByTagNameNSUnsafe ::
+                             (MonadIO m, IsDocument self, ToJSString namespaceURI,
+                              ToJSString localName, HasCallStack) =>
+                               self -> Maybe namespaceURI -> localName -> m NodeList
+getElementsByTagNameNSUnsafe self namespaceURI localName
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_getElementsByTagNameNS (toDocument self)
+             (toMaybeJSString namespaceURI)
+             (toJSString localName)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.getElementsByTagNameNS Mozilla Document.getElementsByTagNameNS documentation> 
 getElementsByTagNameNSUnchecked ::
                                 (MonadIO m, IsDocument self, ToJSString namespaceURI,
                                  ToJSString localName) =>
@@ -603,6 +790,16 @@
       (void (js_getElementById (toDocument self) (toJSString elementId)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.getElementById Mozilla Document.getElementById documentation> 
+getElementByIdUnsafe ::
+                     (MonadIO m, IsDocument self, ToJSString elementId, HasCallStack) =>
+                       self -> elementId -> m Element
+getElementByIdUnsafe self elementId
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_getElementById (toDocument self) (toJSString elementId)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.getElementById Mozilla Document.getElementById documentation> 
 getElementByIdUnchecked ::
                         (MonadIO m, IsDocument self, ToJSString elementId) =>
                           self -> elementId -> m Element
@@ -635,6 +832,17 @@
             (maybeToNullable (fmap toNode source))))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.adoptNode Mozilla Document.adoptNode documentation> 
+adoptNodeUnsafe ::
+                (MonadIO m, IsDocument self, IsNode source, HasCallStack) =>
+                  self -> Maybe source -> m Node
+adoptNodeUnsafe self source
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_adoptNode (toDocument self)
+             (maybeToNullable (fmap toNode source))))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.adoptNode Mozilla Document.adoptNode documentation> 
 adoptNodeUnchecked ::
                    (MonadIO m, IsDocument self, IsNode source) =>
                      self -> Maybe source -> m Node
@@ -665,6 +873,16 @@
       (void (js_createEvent (toDocument self) (toJSString eventType)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.createEvent Mozilla Document.createEvent documentation> 
+createEventUnsafe ::
+                  (MonadIO m, IsDocument self, ToJSString eventType, HasCallStack) =>
+                    self -> eventType -> m Event
+createEventUnsafe self eventType
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_createEvent (toDocument self) (toJSString eventType)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.createEvent Mozilla Document.createEvent documentation> 
 createEventUnchecked ::
                      (MonadIO m, IsDocument self, ToJSString eventType) =>
                        self -> eventType -> m Event
@@ -688,6 +906,14 @@
   = liftIO (void (js_createRange (toDocument self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.createRange Mozilla Document.createRange documentation> 
+createRangeUnsafe ::
+                  (MonadIO m, IsDocument self, HasCallStack) => self -> m Range
+createRangeUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_createRange (toDocument self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.createRange Mozilla Document.createRange documentation> 
 createRangeUnchecked ::
                      (MonadIO m, IsDocument self) => self -> m Range
 createRangeUnchecked self
@@ -732,6 +958,22 @@
             expandEntityReferences))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.createNodeIterator Mozilla Document.createNodeIterator documentation> 
+createNodeIteratorUnsafe ::
+                         (MonadIO m, IsDocument self, IsNode root, HasCallStack) =>
+                           self ->
+                             Maybe root -> Word -> Maybe NodeFilter -> Bool -> m NodeIterator
+createNodeIteratorUnsafe self root whatToShow filter
+  expandEntityReferences
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_createNodeIterator (toDocument self)
+             (maybeToNullable (fmap toNode root))
+             whatToShow
+             (maybeToNullable filter)
+             expandEntityReferences))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.createNodeIterator Mozilla Document.createNodeIterator documentation> 
 createNodeIteratorUnchecked ::
                             (MonadIO m, IsDocument self, IsNode root) =>
                               self ->
@@ -782,6 +1024,22 @@
             expandEntityReferences))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.createTreeWalker Mozilla Document.createTreeWalker documentation> 
+createTreeWalkerUnsafe ::
+                       (MonadIO m, IsDocument self, IsNode root, HasCallStack) =>
+                         self ->
+                           Maybe root -> Word -> Maybe NodeFilter -> Bool -> m TreeWalker
+createTreeWalkerUnsafe self root whatToShow filter
+  expandEntityReferences
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_createTreeWalker (toDocument self)
+             (maybeToNullable (fmap toNode root))
+             whatToShow
+             (maybeToNullable filter)
+             expandEntityReferences))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.createTreeWalker Mozilla Document.createTreeWalker documentation> 
 createTreeWalkerUnchecked ::
                           (MonadIO m, IsDocument self, IsNode root) =>
                             self ->
@@ -827,6 +1085,19 @@
             (toJSString pseudoElement)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.getOverrideStyle Mozilla Document.getOverrideStyle documentation> 
+getOverrideStyleUnsafe ::
+                       (MonadIO m, IsDocument self, IsElement element,
+                        ToJSString pseudoElement, HasCallStack) =>
+                         self -> Maybe element -> pseudoElement -> m CSSStyleDeclaration
+getOverrideStyleUnsafe self element pseudoElement
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_getOverrideStyle (toDocument self)
+             (maybeToNullable (fmap toElement element))
+             (toJSString pseudoElement)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.getOverrideStyle Mozilla Document.getOverrideStyle documentation> 
 getOverrideStyleUnchecked ::
                           (MonadIO m, IsDocument self, IsElement element,
                            ToJSString pseudoElement) =>
@@ -866,6 +1137,18 @@
             (maybeToNullable resolver)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.createExpression Mozilla Document.createExpression documentation> 
+createExpressionUnsafe ::
+                       (MonadIO m, IsDocument self, ToJSString expression,
+                        HasCallStack) =>
+                         self -> expression -> Maybe XPathNSResolver -> m XPathExpression
+createExpressionUnsafe self expression resolver
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_createExpression (toDocument self) (toJSString expression)
+             (maybeToNullable resolver)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.createExpression Mozilla Document.createExpression documentation> 
 createExpressionUnchecked ::
                           (MonadIO m, IsDocument self, ToJSString expression) =>
                             self -> expression -> Maybe XPathNSResolver -> m XPathExpression
@@ -900,6 +1183,17 @@
             (maybeToNullable (fmap toNode nodeResolver))))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.createNSResolver Mozilla Document.createNSResolver documentation> 
+createNSResolverUnsafe ::
+                       (MonadIO m, IsDocument self, IsNode nodeResolver, HasCallStack) =>
+                         self -> Maybe nodeResolver -> m XPathNSResolver
+createNSResolverUnsafe self nodeResolver
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_createNSResolver (toDocument self)
+             (maybeToNullable (fmap toNode nodeResolver))))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.createNSResolver Mozilla Document.createNSResolver documentation> 
 createNSResolverUnchecked ::
                           (MonadIO m, IsDocument self, IsNode nodeResolver) =>
                             self -> Maybe nodeResolver -> m XPathNSResolver
@@ -953,6 +1247,24 @@
             (maybeToNullable inResult)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.evaluate Mozilla Document.evaluate documentation> 
+evaluateUnsafe ::
+               (MonadIO m, IsDocument self, ToJSString expression,
+                IsNode contextNode, HasCallStack) =>
+                 self ->
+                   expression ->
+                     Maybe contextNode ->
+                       Maybe XPathNSResolver -> Word -> Maybe XPathResult -> m XPathResult
+evaluateUnsafe self expression contextNode resolver type' inResult
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_evaluate (toDocument self) (toJSString expression)
+             (maybeToNullable (fmap toNode contextNode))
+             (maybeToNullable resolver)
+             type'
+             (maybeToNullable inResult)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.evaluate Mozilla Document.evaluate documentation> 
 evaluateUnchecked ::
                   (MonadIO m, IsDocument self, ToJSString expression,
                    IsNode contextNode) =>
@@ -1126,6 +1438,17 @@
          (js_getElementsByName (toDocument self) (toJSString elementName)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.getElementsByName Mozilla Document.getElementsByName documentation> 
+getElementsByNameUnsafe ::
+                        (MonadIO m, IsDocument self, ToJSString elementName,
+                         HasCallStack) =>
+                          self -> elementName -> m NodeList
+getElementsByNameUnsafe self elementName
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_getElementsByName (toDocument self) (toJSString elementName)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.getElementsByName Mozilla Document.getElementsByName documentation> 
 getElementsByNameUnchecked ::
                            (MonadIO m, IsDocument self, ToJSString elementName) =>
                              self -> elementName -> m NodeList
@@ -1153,6 +1476,15 @@
   = liftIO (void (js_elementFromPoint (toDocument self) x y))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.elementFromPoint Mozilla Document.elementFromPoint documentation> 
+elementFromPointUnsafe ::
+                       (MonadIO m, IsDocument self, HasCallStack) =>
+                         self -> Int -> Int -> m Element
+elementFromPointUnsafe self x y
+  = liftIO
+      ((nullableToMaybe <$> (js_elementFromPoint (toDocument self) x y))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.elementFromPoint Mozilla Document.elementFromPoint documentation> 
 elementFromPointUnchecked ::
                           (MonadIO m, IsDocument self) => self -> Int -> Int -> m Element
 elementFromPointUnchecked self x y
@@ -1180,6 +1512,16 @@
   = liftIO (void (js_caretRangeFromPoint (toDocument self) x y))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.caretRangeFromPoint Mozilla Document.caretRangeFromPoint documentation> 
+caretRangeFromPointUnsafe ::
+                          (MonadIO m, IsDocument self, HasCallStack) =>
+                            self -> Int -> Int -> m Range
+caretRangeFromPointUnsafe self x y
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_caretRangeFromPoint (toDocument self) x y))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.caretRangeFromPoint Mozilla Document.caretRangeFromPoint documentation> 
 caretRangeFromPointUnchecked ::
                              (MonadIO m, IsDocument self) => self -> Int -> Int -> m Range
 caretRangeFromPointUnchecked self x y
@@ -1202,6 +1544,14 @@
   = liftIO (void (js_getSelection (toDocument self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.getSelection Mozilla Document.getSelection documentation> 
+getSelectionUnsafe ::
+                   (MonadIO m, IsDocument self, HasCallStack) => self -> m Selection
+getSelectionUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getSelection (toDocument self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.getSelection Mozilla Document.getSelection documentation> 
 getSelectionUnchecked ::
                       (MonadIO m, IsDocument self) => self -> m Selection
 getSelectionUnchecked self
@@ -1244,6 +1594,20 @@
             height))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.getCSSCanvasContext Mozilla Document.getCSSCanvasContext documentation> 
+getCSSCanvasContextUnsafe ::
+                          (MonadIO m, IsDocument self, ToJSString contextId, ToJSString name,
+                           HasCallStack) =>
+                            self -> contextId -> name -> Int -> Int -> m CanvasRenderingContext
+getCSSCanvasContextUnsafe self contextId name width height
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_getCSSCanvasContext (toDocument self) (toJSString contextId)
+             (toJSString name)
+             width
+             height))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.getCSSCanvasContext Mozilla Document.getCSSCanvasContext documentation> 
 getCSSCanvasContextUnchecked ::
                              (MonadIO m, IsDocument self, ToJSString contextId,
                               ToJSString name) =>
@@ -1279,6 +1643,16 @@
          (js_getElementsByClassName (toDocument self) (toJSString tagname)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.getElementsByClassName Mozilla Document.getElementsByClassName documentation> 
+getElementsByClassNameUnsafe ::
+                             (MonadIO m, IsDocument self, ToJSString tagname, HasCallStack) =>
+                               self -> tagname -> m NodeList
+getElementsByClassNameUnsafe self tagname
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_getElementsByClassName (toDocument self) (toJSString tagname)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.getElementsByClassName Mozilla Document.getElementsByClassName documentation> 
 getElementsByClassNameUnchecked ::
                                 (MonadIO m, IsDocument self, ToJSString tagname) =>
                                   self -> tagname -> m NodeList
@@ -1319,6 +1693,16 @@
       (void (js_querySelector (toDocument self) (toJSString selectors)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.querySelector Mozilla Document.querySelector documentation> 
+querySelectorUnsafe ::
+                    (MonadIO m, IsDocument self, ToJSString selectors, HasCallStack) =>
+                      self -> selectors -> m Element
+querySelectorUnsafe self selectors
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_querySelector (toDocument self) (toJSString selectors)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.querySelector Mozilla Document.querySelector documentation> 
 querySelectorUnchecked ::
                        (MonadIO m, IsDocument self, ToJSString selectors) =>
                          self -> selectors -> m Element
@@ -1350,6 +1734,16 @@
          (js_querySelectorAll (toDocument self) (toJSString selectors)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.querySelectorAll Mozilla Document.querySelectorAll documentation> 
+querySelectorAllUnsafe ::
+                       (MonadIO m, IsDocument self, ToJSString selectors, HasCallStack) =>
+                         self -> selectors -> m NodeList
+querySelectorAllUnsafe self selectors
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_querySelectorAll (toDocument self) (toJSString selectors)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.querySelectorAll Mozilla Document.querySelectorAll documentation> 
 querySelectorAllUnchecked ::
                           (MonadIO m, IsDocument self, ToJSString selectors) =>
                             self -> selectors -> m NodeList
@@ -1403,6 +1797,15 @@
   = liftIO (void (js_webkitGetNamedFlows (toDocument self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.webkitGetNamedFlows Mozilla Document.webkitGetNamedFlows documentation> 
+webkitGetNamedFlowsUnsafe ::
+                          (MonadIO m, IsDocument self, HasCallStack) =>
+                            self -> m DOMNamedFlowCollection
+webkitGetNamedFlowsUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_webkitGetNamedFlows (toDocument self)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.webkitGetNamedFlows Mozilla Document.webkitGetNamedFlows documentation> 
 webkitGetNamedFlowsUnchecked ::
                              (MonadIO m, IsDocument self) => self -> m DOMNamedFlowCollection
 webkitGetNamedFlowsUnchecked self
@@ -1472,6 +1875,31 @@
             webkitForce))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.createTouch Mozilla Document.createTouch documentation> 
+createTouchUnsafe ::
+                  (MonadIO m, IsDocument self, IsEventTarget target, HasCallStack) =>
+                    self ->
+                      Maybe Window ->
+                        Maybe target ->
+                          Int ->
+                            Int -> Int -> Int -> Int -> Int -> Int -> Float -> Float -> m Touch
+createTouchUnsafe self window target identifier pageX pageY screenX
+  screenY webkitRadiusX webkitRadiusY webkitRotationAngle webkitForce
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_createTouch (toDocument self) (maybeToNullable window)
+             (maybeToNullable (fmap toEventTarget target))
+             identifier
+             pageX
+             pageY
+             screenX
+             screenY
+             webkitRadiusX
+             webkitRadiusY
+             webkitRotationAngle
+             webkitForce))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.createTouch Mozilla Document.createTouch documentation> 
 createTouchUnchecked ::
                      (MonadIO m, IsDocument self, IsEventTarget target) =>
                        self ->
@@ -1512,6 +1940,14 @@
   = liftIO (void (js_createTouchList (toDocument self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.createTouchList Mozilla Document.createTouchList documentation> 
+createTouchListUnsafe ::
+                      (MonadIO m, IsDocument self, HasCallStack) => self -> m TouchList
+createTouchListUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_createTouchList (toDocument self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.createTouchList Mozilla Document.createTouchList documentation> 
 createTouchListUnchecked ::
                          (MonadIO m, IsDocument self) => self -> m TouchList
 createTouchListUnchecked self
@@ -1529,6 +1965,15 @@
   = liftIO (nullableToMaybe <$> (js_getDoctype (toDocument self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.doctype Mozilla Document.doctype documentation> 
+getDoctypeUnsafe ::
+                 (MonadIO m, IsDocument self, HasCallStack) =>
+                   self -> m DocumentType
+getDoctypeUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getDoctype (toDocument self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.doctype Mozilla Document.doctype documentation> 
 getDoctypeUnchecked ::
                     (MonadIO m, IsDocument self) => self -> m DocumentType
 getDoctypeUnchecked self
@@ -1546,6 +1991,15 @@
       (nullableToMaybe <$> (js_getImplementation (toDocument self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.implementation Mozilla Document.implementation documentation> 
+getImplementationUnsafe ::
+                        (MonadIO m, IsDocument self, HasCallStack) =>
+                          self -> m DOMImplementation
+getImplementationUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getImplementation (toDocument self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.implementation Mozilla Document.implementation documentation> 
 getImplementationUnchecked ::
                            (MonadIO m, IsDocument self) => self -> m DOMImplementation
 getImplementationUnchecked self
@@ -1564,6 +2018,14 @@
       (nullableToMaybe <$> (js_getDocumentElement (toDocument self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.documentElement Mozilla Document.documentElement documentation> 
+getDocumentElementUnsafe ::
+                         (MonadIO m, IsDocument self, HasCallStack) => self -> m Element
+getDocumentElementUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getDocumentElement (toDocument self)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.documentElement Mozilla Document.documentElement documentation> 
 getDocumentElementUnchecked ::
                             (MonadIO m, IsDocument self) => self -> m Element
 getDocumentElementUnchecked self
@@ -1583,6 +2045,15 @@
       (fromMaybeJSString <$> (js_getInputEncoding (toDocument self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.inputEncoding Mozilla Document.inputEncoding documentation> 
+getInputEncodingUnsafe ::
+                       (MonadIO m, IsDocument self, HasCallStack, FromJSString result) =>
+                         self -> m result
+getInputEncodingUnsafe self
+  = liftIO
+      ((fromMaybeJSString <$> (js_getInputEncoding (toDocument self)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.inputEncoding Mozilla Document.inputEncoding documentation> 
 getInputEncodingUnchecked ::
                           (MonadIO m, IsDocument self, FromJSString result) =>
                             self -> m result
@@ -1603,6 +2074,15 @@
       (fromMaybeJSString <$> (js_getXmlEncoding (toDocument self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.xmlEncoding Mozilla Document.xmlEncoding documentation> 
+getXmlEncodingUnsafe ::
+                     (MonadIO m, IsDocument self, HasCallStack, FromJSString result) =>
+                       self -> m result
+getXmlEncodingUnsafe self
+  = liftIO
+      ((fromMaybeJSString <$> (js_getXmlEncoding (toDocument self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.xmlEncoding Mozilla Document.xmlEncoding documentation> 
 getXmlEncodingUnchecked ::
                         (MonadIO m, IsDocument self, FromJSString result) =>
                           self -> m result
@@ -1633,6 +2113,15 @@
       (fromMaybeJSString <$> (js_getXmlVersion (toDocument self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.xmlVersion Mozilla Document.xmlVersion documentation> 
+getXmlVersionUnsafe ::
+                    (MonadIO m, IsDocument self, HasCallStack, FromJSString result) =>
+                      self -> m result
+getXmlVersionUnsafe self
+  = liftIO
+      ((fromMaybeJSString <$> (js_getXmlVersion (toDocument self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.xmlVersion Mozilla Document.xmlVersion documentation> 
 getXmlVersionUnchecked ::
                        (MonadIO m, IsDocument self, FromJSString result) =>
                          self -> m result
@@ -1670,6 +2159,15 @@
       (fromMaybeJSString <$> (js_getDocumentURI (toDocument self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.documentURI Mozilla Document.documentURI documentation> 
+getDocumentURIUnsafe ::
+                     (MonadIO m, IsDocument self, HasCallStack, FromJSString result) =>
+                       self -> m result
+getDocumentURIUnsafe self
+  = liftIO
+      ((fromMaybeJSString <$> (js_getDocumentURI (toDocument self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.documentURI Mozilla Document.documentURI documentation> 
 getDocumentURIUnchecked ::
                         (MonadIO m, IsDocument self, FromJSString result) =>
                           self -> m result
@@ -1689,6 +2187,14 @@
       (nullableToMaybe <$> (js_getDefaultView (toDocument self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.defaultView Mozilla Document.defaultView documentation> 
+getDefaultViewUnsafe ::
+                     (MonadIO m, IsDocument self, HasCallStack) => self -> m Window
+getDefaultViewUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getDefaultView (toDocument self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.defaultView Mozilla Document.defaultView documentation> 
 getDefaultViewUnchecked ::
                         (MonadIO m, IsDocument self) => self -> m Window
 getDefaultViewUnchecked self
@@ -1707,6 +2213,15 @@
       (nullableToMaybe <$> (js_getStyleSheets (toDocument self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.styleSheets Mozilla Document.styleSheets documentation> 
+getStyleSheetsUnsafe ::
+                     (MonadIO m, IsDocument self, HasCallStack) =>
+                       self -> m StyleSheetList
+getStyleSheetsUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getStyleSheets (toDocument self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.styleSheets Mozilla Document.styleSheets documentation> 
 getStyleSheetsUnchecked ::
                         (MonadIO m, IsDocument self) => self -> m StyleSheetList
 getStyleSheetsUnchecked self
@@ -1745,6 +2260,15 @@
   = liftIO (fromMaybeJSString <$> (js_getTitle (toDocument self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.title Mozilla Document.title documentation> 
+getTitleUnsafe ::
+               (MonadIO m, IsDocument self, HasCallStack, FromJSString result) =>
+                 self -> m result
+getTitleUnsafe self
+  = liftIO
+      ((fromMaybeJSString <$> (js_getTitle (toDocument self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.title Mozilla Document.title documentation> 
 getTitleUnchecked ::
                   (MonadIO m, IsDocument self, FromJSString result) =>
                     self -> m result
@@ -1783,6 +2307,15 @@
   = liftIO (fromMaybeJSString <$> (js_getDomain (toDocument self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.domain Mozilla Document.domain documentation> 
+getDomainUnsafe ::
+                (MonadIO m, IsDocument self, HasCallStack, FromJSString result) =>
+                  self -> m result
+getDomainUnsafe self
+  = liftIO
+      ((fromMaybeJSString <$> (js_getDomain (toDocument self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.domain Mozilla Document.domain documentation> 
 getDomainUnchecked ::
                    (MonadIO m, IsDocument self, FromJSString result) =>
                      self -> m result
@@ -1821,6 +2354,15 @@
   = liftIO (fromMaybeJSString <$> (js_getCookie (toDocument self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.cookie Mozilla Document.cookie documentation> 
+getCookieUnsafe ::
+                (MonadIO m, IsDocument self, HasCallStack, FromJSString result) =>
+                  self -> m result
+getCookieUnsafe self
+  = liftIO
+      ((fromMaybeJSString <$> (js_getCookie (toDocument self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.cookie Mozilla Document.cookie documentation> 
 getCookieUnchecked ::
                    (MonadIO m, IsDocument self, FromJSString result) =>
                      self -> m result
@@ -1850,6 +2392,14 @@
   = liftIO (nullableToMaybe <$> (js_getBody (toDocument self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.body Mozilla Document.body documentation> 
+getBodyUnsafe ::
+              (MonadIO m, IsDocument self, HasCallStack) => self -> m HTMLElement
+getBodyUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getBody (toDocument self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.body Mozilla Document.body documentation> 
 getBodyUnchecked ::
                  (MonadIO m, IsDocument self) => self -> m HTMLElement
 getBodyUnchecked self
@@ -1866,6 +2416,15 @@
   = liftIO (nullableToMaybe <$> (js_getHead (toDocument self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.head Mozilla Document.head documentation> 
+getHeadUnsafe ::
+              (MonadIO m, IsDocument self, HasCallStack) =>
+                self -> m HTMLHeadElement
+getHeadUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getHead (toDocument self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.head Mozilla Document.head documentation> 
 getHeadUnchecked ::
                  (MonadIO m, IsDocument self) => self -> m HTMLHeadElement
 getHeadUnchecked self
@@ -1882,6 +2441,15 @@
   = liftIO (nullableToMaybe <$> (js_getImages (toDocument self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.images Mozilla Document.images documentation> 
+getImagesUnsafe ::
+                (MonadIO m, IsDocument self, HasCallStack) =>
+                  self -> m HTMLCollection
+getImagesUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getImages (toDocument self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.images Mozilla Document.images documentation> 
 getImagesUnchecked ::
                    (MonadIO m, IsDocument self) => self -> m HTMLCollection
 getImagesUnchecked self
@@ -1898,6 +2466,15 @@
   = liftIO (nullableToMaybe <$> (js_getApplets (toDocument self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.applets Mozilla Document.applets documentation> 
+getAppletsUnsafe ::
+                 (MonadIO m, IsDocument self, HasCallStack) =>
+                   self -> m HTMLCollection
+getAppletsUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getApplets (toDocument self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.applets Mozilla Document.applets documentation> 
 getAppletsUnchecked ::
                     (MonadIO m, IsDocument self) => self -> m HTMLCollection
 getAppletsUnchecked self
@@ -1914,6 +2491,15 @@
   = liftIO (nullableToMaybe <$> (js_getLinks (toDocument self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.links Mozilla Document.links documentation> 
+getLinksUnsafe ::
+               (MonadIO m, IsDocument self, HasCallStack) =>
+                 self -> m HTMLCollection
+getLinksUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getLinks (toDocument self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.links Mozilla Document.links documentation> 
 getLinksUnchecked ::
                   (MonadIO m, IsDocument self) => self -> m HTMLCollection
 getLinksUnchecked self
@@ -1930,6 +2516,15 @@
   = liftIO (nullableToMaybe <$> (js_getForms (toDocument self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.forms Mozilla Document.forms documentation> 
+getFormsUnsafe ::
+               (MonadIO m, IsDocument self, HasCallStack) =>
+                 self -> m HTMLCollection
+getFormsUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getForms (toDocument self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.forms Mozilla Document.forms documentation> 
 getFormsUnchecked ::
                   (MonadIO m, IsDocument self) => self -> m HTMLCollection
 getFormsUnchecked self
@@ -1946,6 +2541,15 @@
   = liftIO (nullableToMaybe <$> (js_getAnchors (toDocument self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.anchors Mozilla Document.anchors documentation> 
+getAnchorsUnsafe ::
+                 (MonadIO m, IsDocument self, HasCallStack) =>
+                   self -> m HTMLCollection
+getAnchorsUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getAnchors (toDocument self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.anchors Mozilla Document.anchors documentation> 
 getAnchorsUnchecked ::
                     (MonadIO m, IsDocument self) => self -> m HTMLCollection
 getAnchorsUnchecked self
@@ -1981,6 +2585,14 @@
   = liftIO (nullableToMaybe <$> (js_getLocation (toDocument self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.location Mozilla Document.location documentation> 
+getLocationUnsafe ::
+                  (MonadIO m, IsDocument self, HasCallStack) => self -> m Location
+getLocationUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getLocation (toDocument self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.location Mozilla Document.location documentation> 
 getLocationUnchecked ::
                      (MonadIO m, IsDocument self) => self -> m Location
 getLocationUnchecked self
@@ -2008,6 +2620,15 @@
   = liftIO (fromMaybeJSString <$> (js_getCharset (toDocument self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.charset Mozilla Document.charset documentation> 
+getCharsetUnsafe ::
+                 (MonadIO m, IsDocument self, HasCallStack, FromJSString result) =>
+                   self -> m result
+getCharsetUnsafe self
+  = liftIO
+      ((fromMaybeJSString <$> (js_getCharset (toDocument self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.charset Mozilla Document.charset documentation> 
 getCharsetUnchecked ::
                     (MonadIO m, IsDocument self, FromJSString result) =>
                       self -> m result
@@ -2028,6 +2649,15 @@
       (fromMaybeJSString <$> (js_getDefaultCharset (toDocument self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.defaultCharset Mozilla Document.defaultCharset documentation> 
+getDefaultCharsetUnsafe ::
+                        (MonadIO m, IsDocument self, HasCallStack, FromJSString result) =>
+                          self -> m result
+getDefaultCharsetUnsafe self
+  = liftIO
+      ((fromMaybeJSString <$> (js_getDefaultCharset (toDocument self)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.defaultCharset Mozilla Document.defaultCharset documentation> 
 getDefaultCharsetUnchecked ::
                            (MonadIO m, IsDocument self, FromJSString result) =>
                              self -> m result
@@ -2048,6 +2678,15 @@
       (fromMaybeJSString <$> (js_getReadyState (toDocument self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.readyState Mozilla Document.readyState documentation> 
+getReadyStateUnsafe ::
+                    (MonadIO m, IsDocument self, HasCallStack, FromJSString result) =>
+                      self -> m result
+getReadyStateUnsafe self
+  = liftIO
+      ((fromMaybeJSString <$> (js_getReadyState (toDocument self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.readyState Mozilla Document.readyState documentation> 
 getReadyStateUnchecked ::
                        (MonadIO m, IsDocument self, FromJSString result) =>
                          self -> m result
@@ -2068,6 +2707,15 @@
       (fromMaybeJSString <$> (js_getCharacterSet (toDocument self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.characterSet Mozilla Document.characterSet documentation> 
+getCharacterSetUnsafe ::
+                      (MonadIO m, IsDocument self, HasCallStack, FromJSString result) =>
+                        self -> m result
+getCharacterSetUnsafe self
+  = liftIO
+      ((fromMaybeJSString <$> (js_getCharacterSet (toDocument self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.characterSet Mozilla Document.characterSet documentation> 
 getCharacterSetUnchecked ::
                          (MonadIO m, IsDocument self, FromJSString result) =>
                            self -> m result
@@ -2089,6 +2737,16 @@
          (js_getPreferredStylesheetSet (toDocument self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.preferredStylesheetSet Mozilla Document.preferredStylesheetSet documentation> 
+getPreferredStylesheetSetUnsafe ::
+                                (MonadIO m, IsDocument self, HasCallStack, FromJSString result) =>
+                                  self -> m result
+getPreferredStylesheetSetUnsafe self
+  = liftIO
+      ((fromMaybeJSString <$>
+          (js_getPreferredStylesheetSet (toDocument self)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.preferredStylesheetSet Mozilla Document.preferredStylesheetSet documentation> 
 getPreferredStylesheetSetUnchecked ::
                                    (MonadIO m, IsDocument self, FromJSString result) =>
                                      self -> m result
@@ -2123,6 +2781,16 @@
          (js_getSelectedStylesheetSet (toDocument self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.selectedStylesheetSet Mozilla Document.selectedStylesheetSet documentation> 
+getSelectedStylesheetSetUnsafe ::
+                               (MonadIO m, IsDocument self, HasCallStack, FromJSString result) =>
+                                 self -> m result
+getSelectedStylesheetSetUnsafe self
+  = liftIO
+      ((fromMaybeJSString <$>
+          (js_getSelectedStylesheetSet (toDocument self)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.selectedStylesheetSet Mozilla Document.selectedStylesheetSet documentation> 
 getSelectedStylesheetSetUnchecked ::
                                   (MonadIO m, IsDocument self, FromJSString result) =>
                                     self -> m result
@@ -2142,6 +2810,14 @@
       (nullableToMaybe <$> (js_getActiveElement (toDocument self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.activeElement Mozilla Document.activeElement documentation> 
+getActiveElementUnsafe ::
+                       (MonadIO m, IsDocument self, HasCallStack) => self -> m Element
+getActiveElementUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getActiveElement (toDocument self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.activeElement Mozilla Document.activeElement documentation> 
 getActiveElementUnchecked ::
                           (MonadIO m, IsDocument self) => self -> m Element
 getActiveElementUnchecked self
@@ -2194,6 +2870,16 @@
          (js_getWebkitCurrentFullScreenElement (toDocument self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.webkitCurrentFullScreenElement Mozilla Document.webkitCurrentFullScreenElement documentation> 
+getWebkitCurrentFullScreenElementUnsafe ::
+                                        (MonadIO m, IsDocument self, HasCallStack) =>
+                                          self -> m Element
+getWebkitCurrentFullScreenElementUnsafe self
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_getWebkitCurrentFullScreenElement (toDocument self)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.webkitCurrentFullScreenElement Mozilla Document.webkitCurrentFullScreenElement documentation> 
 getWebkitCurrentFullScreenElementUnchecked ::
                                            (MonadIO m, IsDocument self) => self -> m Element
 getWebkitCurrentFullScreenElementUnchecked self
@@ -2223,6 +2909,15 @@
          (js_getWebkitFullscreenElement (toDocument self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.webkitFullscreenElement Mozilla Document.webkitFullscreenElement documentation> 
+getWebkitFullscreenElementUnsafe ::
+                                 (MonadIO m, IsDocument self, HasCallStack) => self -> m Element
+getWebkitFullscreenElementUnsafe self
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_getWebkitFullscreenElement (toDocument self)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.webkitFullscreenElement Mozilla Document.webkitFullscreenElement documentation> 
 getWebkitFullscreenElementUnchecked ::
                                     (MonadIO m, IsDocument self) => self -> m Element
 getWebkitFullscreenElementUnchecked self
@@ -2241,6 +2936,14 @@
       (nullableToMaybe <$> (js_getPointerLockElement (toDocument self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.pointerLockElement Mozilla Document.pointerLockElement documentation> 
+getPointerLockElementUnsafe ::
+                            (MonadIO m, IsDocument self, HasCallStack) => self -> m Element
+getPointerLockElementUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getPointerLockElement (toDocument self)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.pointerLockElement Mozilla Document.pointerLockElement documentation> 
 getPointerLockElementUnchecked ::
                                (MonadIO m, IsDocument self) => self -> m Element
 getPointerLockElementUnchecked self
@@ -2258,6 +2961,14 @@
   = liftIO (nullableToMaybe <$> (js_getFonts (toDocument self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.fonts Mozilla Document.fonts documentation> 
+getFontsUnsafe ::
+               (MonadIO m, IsDocument self, HasCallStack) => self -> m FontLoader
+getFontsUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getFonts (toDocument self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.fonts Mozilla Document.fonts documentation> 
 getFontsUnchecked ::
                   (MonadIO m, IsDocument self) => self -> m FontLoader
 getFontsUnchecked self
@@ -2591,6 +3302,15 @@
       (nullableToMaybe <$> (js_getSecurityPolicy (toDocument self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.securityPolicy Mozilla Document.securityPolicy documentation> 
+getSecurityPolicyUnsafe ::
+                        (MonadIO m, IsDocument self, HasCallStack) =>
+                          self -> m SecurityPolicy
+getSecurityPolicyUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getSecurityPolicy (toDocument self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.securityPolicy Mozilla Document.securityPolicy documentation> 
 getSecurityPolicyUnchecked ::
                            (MonadIO m, IsDocument self) => self -> m SecurityPolicy
 getSecurityPolicyUnchecked self
@@ -2607,6 +3327,15 @@
 getCurrentScript self
   = liftIO
       (nullableToMaybe <$> (js_getCurrentScript (toDocument self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.currentScript Mozilla Document.currentScript documentation> 
+getCurrentScriptUnsafe ::
+                       (MonadIO m, IsDocument self, HasCallStack) =>
+                         self -> m HTMLScriptElement
+getCurrentScriptUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getCurrentScript (toDocument self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Document.currentScript Mozilla Document.currentScript documentation> 
 getCurrentScriptUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/DocumentFragment.hs b/src/GHCJS/DOM/JSFFI/Generated/DocumentFragment.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/DocumentFragment.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/DocumentFragment.hs
@@ -1,12 +1,19 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.DocumentFragment
        (js_newDocumentFragment, newDocumentFragment, js_querySelector,
-        querySelector, querySelector_, querySelectorUnchecked,
-        js_querySelectorAll, querySelectorAll, querySelectorAll_,
-        querySelectorAllUnchecked, DocumentFragment,
-        castToDocumentFragment, gTypeDocumentFragment)
+        querySelector, querySelector_, querySelectorUnsafe,
+        querySelectorUnchecked, js_querySelectorAll, querySelectorAll,
+        querySelectorAll_, querySelectorAllUnsafe,
+        querySelectorAllUnchecked, DocumentFragment(..),
+        gTypeDocumentFragment)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -22,6 +29,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe
         "new window[\"DocumentFragment\"]()" js_newDocumentFragment ::
@@ -52,6 +69,16 @@
   = liftIO (void (js_querySelector (self) (toJSString selectors)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/DocumentFragment.querySelector Mozilla DocumentFragment.querySelector documentation> 
+querySelectorUnsafe ::
+                    (MonadIO m, ToJSString selectors, HasCallStack) =>
+                      DocumentFragment -> selectors -> m Element
+querySelectorUnsafe self selectors
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_querySelector (self) (toJSString selectors)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/DocumentFragment.querySelector Mozilla DocumentFragment.querySelector documentation> 
 querySelectorUnchecked ::
                        (MonadIO m, ToJSString selectors) =>
                          DocumentFragment -> selectors -> m Element
@@ -79,6 +106,16 @@
                     DocumentFragment -> selectors -> m ()
 querySelectorAll_ self selectors
   = liftIO (void (js_querySelectorAll (self) (toJSString selectors)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/DocumentFragment.querySelectorAll Mozilla DocumentFragment.querySelectorAll documentation> 
+querySelectorAllUnsafe ::
+                       (MonadIO m, ToJSString selectors, HasCallStack) =>
+                         DocumentFragment -> selectors -> m NodeList
+querySelectorAllUnsafe self selectors
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_querySelectorAll (self) (toJSString selectors)))
+         >>= maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/DocumentFragment.querySelectorAll Mozilla DocumentFragment.querySelectorAll documentation> 
 querySelectorAllUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/DocumentType.hs b/src/GHCJS/DOM/JSFFI/Generated/DocumentType.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/DocumentType.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/DocumentType.hs
@@ -1,14 +1,21 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.DocumentType
        (js_getName, getName, js_getEntities, getEntities,
-        getEntitiesUnchecked, js_getNotations, getNotations,
-        getNotationsUnchecked, js_getPublicId, getPublicId,
+        getEntitiesUnsafe, getEntitiesUnchecked, js_getNotations,
+        getNotations, getNotationsUnsafe, getNotationsUnchecked,
+        js_getPublicId, getPublicId, getPublicIdUnsafe,
         getPublicIdUnchecked, js_getSystemId, getSystemId,
-        getSystemIdUnchecked, js_getInternalSubset, getInternalSubset,
-        getInternalSubsetUnchecked, DocumentType, castToDocumentType,
-        gTypeDocumentType)
+        getSystemIdUnsafe, getSystemIdUnchecked, js_getInternalSubset,
+        getInternalSubset, getInternalSubsetUnsafe,
+        getInternalSubsetUnchecked, DocumentType(..), gTypeDocumentType)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -24,6 +31,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"name\"]" js_getName ::
         DocumentType -> IO JSString
@@ -43,6 +60,14 @@
   = liftIO (nullableToMaybe <$> (js_getEntities (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/DocumentType.entities Mozilla DocumentType.entities documentation> 
+getEntitiesUnsafe ::
+                  (MonadIO m, HasCallStack) => DocumentType -> m NamedNodeMap
+getEntitiesUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getEntities (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/DocumentType.entities Mozilla DocumentType.entities documentation> 
 getEntitiesUnchecked ::
                      (MonadIO m) => DocumentType -> m NamedNodeMap
 getEntitiesUnchecked self
@@ -58,6 +83,14 @@
   = liftIO (nullableToMaybe <$> (js_getNotations (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/DocumentType.notations Mozilla DocumentType.notations documentation> 
+getNotationsUnsafe ::
+                   (MonadIO m, HasCallStack) => DocumentType -> m NamedNodeMap
+getNotationsUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getNotations (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/DocumentType.notations Mozilla DocumentType.notations documentation> 
 getNotationsUnchecked ::
                       (MonadIO m) => DocumentType -> m NamedNodeMap
 getNotationsUnchecked self
@@ -74,6 +107,15 @@
   = liftIO (fromMaybeJSString <$> (js_getPublicId (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/DocumentType.publicId Mozilla DocumentType.publicId documentation> 
+getPublicIdUnsafe ::
+                  (MonadIO m, HasCallStack, FromJSString result) =>
+                    DocumentType -> m result
+getPublicIdUnsafe self
+  = liftIO
+      ((fromMaybeJSString <$> (js_getPublicId (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/DocumentType.publicId Mozilla DocumentType.publicId documentation> 
 getPublicIdUnchecked ::
                      (MonadIO m, FromJSString result) => DocumentType -> m result
 getPublicIdUnchecked self
@@ -90,6 +132,15 @@
   = liftIO (fromMaybeJSString <$> (js_getSystemId (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/DocumentType.systemId Mozilla DocumentType.systemId documentation> 
+getSystemIdUnsafe ::
+                  (MonadIO m, HasCallStack, FromJSString result) =>
+                    DocumentType -> m result
+getSystemIdUnsafe self
+  = liftIO
+      ((fromMaybeJSString <$> (js_getSystemId (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/DocumentType.systemId Mozilla DocumentType.systemId documentation> 
 getSystemIdUnchecked ::
                      (MonadIO m, FromJSString result) => DocumentType -> m result
 getSystemIdUnchecked self
@@ -104,6 +155,15 @@
                     DocumentType -> m (Maybe result)
 getInternalSubset self
   = liftIO (fromMaybeJSString <$> (js_getInternalSubset (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/DocumentType.internalSubset Mozilla DocumentType.internalSubset documentation> 
+getInternalSubsetUnsafe ::
+                        (MonadIO m, HasCallStack, FromJSString result) =>
+                          DocumentType -> m result
+getInternalSubsetUnsafe self
+  = liftIO
+      ((fromMaybeJSString <$> (js_getInternalSubset (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/DocumentType.internalSubset Mozilla DocumentType.internalSubset documentation> 
 getInternalSubsetUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/DynamicsCompressorNode.hs b/src/GHCJS/DOM/JSFFI/Generated/DynamicsCompressorNode.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/DynamicsCompressorNode.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/DynamicsCompressorNode.hs
@@ -1,14 +1,21 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.DynamicsCompressorNode
-       (js_getThreshold, getThreshold, getThresholdUnchecked, js_getKnee,
-        getKnee, getKneeUnchecked, js_getRatio, getRatio,
+       (js_getThreshold, getThreshold, getThresholdUnsafe,
+        getThresholdUnchecked, js_getKnee, getKnee, getKneeUnsafe,
+        getKneeUnchecked, js_getRatio, getRatio, getRatioUnsafe,
         getRatioUnchecked, js_getReduction, getReduction,
-        getReductionUnchecked, js_getAttack, getAttack, getAttackUnchecked,
-        js_getRelease, getRelease, getReleaseUnchecked,
-        DynamicsCompressorNode, castToDynamicsCompressorNode,
+        getReductionUnsafe, getReductionUnchecked, js_getAttack, getAttack,
+        getAttackUnsafe, getAttackUnchecked, js_getRelease, getRelease,
+        getReleaseUnsafe, getReleaseUnchecked, DynamicsCompressorNode(..),
         gTypeDynamicsCompressorNode)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -24,6 +31,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"threshold\"]"
         js_getThreshold ::
@@ -36,6 +53,14 @@
   = liftIO (nullableToMaybe <$> (js_getThreshold (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/DynamicsCompressorNode.threshold Mozilla DynamicsCompressorNode.threshold documentation> 
+getThresholdUnsafe ::
+                   (MonadIO m, HasCallStack) => DynamicsCompressorNode -> m AudioParam
+getThresholdUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getThreshold (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/DynamicsCompressorNode.threshold Mozilla DynamicsCompressorNode.threshold documentation> 
 getThresholdUnchecked ::
                       (MonadIO m) => DynamicsCompressorNode -> m AudioParam
 getThresholdUnchecked self
@@ -50,6 +75,14 @@
 getKnee self = liftIO (nullableToMaybe <$> (js_getKnee (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/DynamicsCompressorNode.knee Mozilla DynamicsCompressorNode.knee documentation> 
+getKneeUnsafe ::
+              (MonadIO m, HasCallStack) => DynamicsCompressorNode -> m AudioParam
+getKneeUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getKnee (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/DynamicsCompressorNode.knee Mozilla DynamicsCompressorNode.knee documentation> 
 getKneeUnchecked ::
                  (MonadIO m) => DynamicsCompressorNode -> m AudioParam
 getKneeUnchecked self
@@ -64,6 +97,14 @@
 getRatio self = liftIO (nullableToMaybe <$> (js_getRatio (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/DynamicsCompressorNode.ratio Mozilla DynamicsCompressorNode.ratio documentation> 
+getRatioUnsafe ::
+               (MonadIO m, HasCallStack) => DynamicsCompressorNode -> m AudioParam
+getRatioUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getRatio (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/DynamicsCompressorNode.ratio Mozilla DynamicsCompressorNode.ratio documentation> 
 getRatioUnchecked ::
                   (MonadIO m) => DynamicsCompressorNode -> m AudioParam
 getRatioUnchecked self
@@ -80,6 +121,14 @@
   = liftIO (nullableToMaybe <$> (js_getReduction (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/DynamicsCompressorNode.reduction Mozilla DynamicsCompressorNode.reduction documentation> 
+getReductionUnsafe ::
+                   (MonadIO m, HasCallStack) => DynamicsCompressorNode -> m AudioParam
+getReductionUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getReduction (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/DynamicsCompressorNode.reduction Mozilla DynamicsCompressorNode.reduction documentation> 
 getReductionUnchecked ::
                       (MonadIO m) => DynamicsCompressorNode -> m AudioParam
 getReductionUnchecked self
@@ -94,6 +143,14 @@
 getAttack self = liftIO (nullableToMaybe <$> (js_getAttack (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/DynamicsCompressorNode.attack Mozilla DynamicsCompressorNode.attack documentation> 
+getAttackUnsafe ::
+                (MonadIO m, HasCallStack) => DynamicsCompressorNode -> m AudioParam
+getAttackUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getAttack (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/DynamicsCompressorNode.attack Mozilla DynamicsCompressorNode.attack documentation> 
 getAttackUnchecked ::
                    (MonadIO m) => DynamicsCompressorNode -> m AudioParam
 getAttackUnchecked self
@@ -107,6 +164,14 @@
            (MonadIO m) => DynamicsCompressorNode -> m (Maybe AudioParam)
 getRelease self
   = liftIO (nullableToMaybe <$> (js_getRelease (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/DynamicsCompressorNode.release Mozilla DynamicsCompressorNode.release documentation> 
+getReleaseUnsafe ::
+                 (MonadIO m, HasCallStack) => DynamicsCompressorNode -> m AudioParam
+getReleaseUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getRelease (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/DynamicsCompressorNode.release Mozilla DynamicsCompressorNode.release documentation> 
 getReleaseUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/EXTBlendMinMax.hs b/src/GHCJS/DOM/JSFFI/Generated/EXTBlendMinMax.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/EXTBlendMinMax.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/EXTBlendMinMax.hs
@@ -1,9 +1,15 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.EXTBlendMinMax
-       (pattern MIN_EXT, pattern MAX_EXT, EXTBlendMinMax,
-        castToEXTBlendMinMax, gTypeEXTBlendMinMax)
+       (pattern MIN_EXT, pattern MAX_EXT, EXTBlendMinMax(..),
+        gTypeEXTBlendMinMax)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -19,5 +25,15 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
 pattern MIN_EXT = 32775
 pattern MAX_EXT = 32776
diff --git a/src/GHCJS/DOM/JSFFI/Generated/EXTTextureFilterAnisotropic.hs b/src/GHCJS/DOM/JSFFI/Generated/EXTTextureFilterAnisotropic.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/EXTTextureFilterAnisotropic.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/EXTTextureFilterAnisotropic.hs
@@ -1,11 +1,16 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.EXTTextureFilterAnisotropic
        (pattern TEXTURE_MAX_ANISOTROPY_EXT,
         pattern MAX_TEXTURE_MAX_ANISOTROPY_EXT,
-        EXTTextureFilterAnisotropic, castToEXTTextureFilterAnisotropic,
-        gTypeEXTTextureFilterAnisotropic)
+        EXTTextureFilterAnisotropic(..), gTypeEXTTextureFilterAnisotropic)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -21,5 +26,15 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
 pattern TEXTURE_MAX_ANISOTROPY_EXT = 34046
 pattern MAX_TEXTURE_MAX_ANISOTROPY_EXT = 34047
diff --git a/src/GHCJS/DOM/JSFFI/Generated/EXTsRGB.hs b/src/GHCJS/DOM/JSFFI/Generated/EXTsRGB.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/EXTsRGB.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/EXTsRGB.hs
@@ -1,11 +1,17 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.EXTsRGB
        (pattern SRGB_EXT, pattern SRGB_ALPHA_EXT,
         pattern SRGB8_ALPHA8_EXT,
-        pattern FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING_EXT, EXTsRGB,
-        castToEXTsRGB, gTypeEXTsRGB)
+        pattern FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING_EXT, EXTsRGB(..),
+        gTypeEXTsRGB)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -21,6 +27,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
 pattern SRGB_EXT = 35904
 pattern SRGB_ALPHA_EXT = 35906
 pattern SRGB8_ALPHA8_EXT = 35907
diff --git a/src/GHCJS/DOM/JSFFI/Generated/Element.hs b/src/GHCJS/DOM/JSFFI/Generated/Element.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/Element.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/Element.hs
@@ -1,45 +1,56 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.Element
-       (js_getAttribute, getAttribute, getAttribute_,
+       (js_getAttribute, getAttribute, getAttribute_, getAttributeUnsafe,
         getAttributeUnchecked, js_setAttribute, setAttribute,
         js_removeAttribute, removeAttribute, js_getAttributeNode,
-        getAttributeNode, getAttributeNode_, getAttributeNodeUnchecked,
-        js_setAttributeNode, setAttributeNode, setAttributeNode_,
+        getAttributeNode, getAttributeNode_, getAttributeNodeUnsafe,
+        getAttributeNodeUnchecked, js_setAttributeNode, setAttributeNode,
+        setAttributeNode_, setAttributeNodeUnsafe,
         setAttributeNodeUnchecked, js_removeAttributeNode,
         removeAttributeNode, removeAttributeNode_,
-        removeAttributeNodeUnchecked, js_getElementsByTagName,
-        getElementsByTagName, getElementsByTagName_,
+        removeAttributeNodeUnsafe, removeAttributeNodeUnchecked,
+        js_getElementsByTagName, getElementsByTagName,
+        getElementsByTagName_, getElementsByTagNameUnsafe,
         getElementsByTagNameUnchecked, js_hasAttributes, hasAttributes,
         hasAttributes_, js_getAttributeNS, getAttributeNS, getAttributeNS_,
         js_setAttributeNS, setAttributeNS, js_removeAttributeNS,
         removeAttributeNS, js_getElementsByTagNameNS,
         getElementsByTagNameNS, getElementsByTagNameNS_,
-        getElementsByTagNameNSUnchecked, js_getAttributeNodeNS,
-        getAttributeNodeNS, getAttributeNodeNS_,
-        getAttributeNodeNSUnchecked, js_setAttributeNodeNS,
-        setAttributeNodeNS, setAttributeNodeNS_,
-        setAttributeNodeNSUnchecked, js_hasAttribute, hasAttribute,
-        hasAttribute_, js_hasAttributeNS, hasAttributeNS, hasAttributeNS_,
-        js_focus, focus, js_blur, blur, js_scrollIntoView, scrollIntoView,
-        js_scrollIntoViewIfNeeded, scrollIntoViewIfNeeded,
-        js_scrollByLines, scrollByLines, js_scrollByPages, scrollByPages,
-        js_getElementsByClassName, getElementsByClassName,
-        getElementsByClassName_, getElementsByClassNameUnchecked,
+        getElementsByTagNameNSUnsafe, getElementsByTagNameNSUnchecked,
+        js_getAttributeNodeNS, getAttributeNodeNS, getAttributeNodeNS_,
+        getAttributeNodeNSUnsafe, getAttributeNodeNSUnchecked,
+        js_setAttributeNodeNS, setAttributeNodeNS, setAttributeNodeNS_,
+        setAttributeNodeNSUnsafe, setAttributeNodeNSUnchecked,
+        js_hasAttribute, hasAttribute, hasAttribute_, js_hasAttributeNS,
+        hasAttributeNS, hasAttributeNS_, js_focus, focus, js_blur, blur,
+        js_scrollIntoView, scrollIntoView, js_scrollIntoViewIfNeeded,
+        scrollIntoViewIfNeeded, js_scrollByLines, scrollByLines,
+        js_scrollByPages, scrollByPages, js_getElementsByClassName,
+        getElementsByClassName, getElementsByClassName_,
+        getElementsByClassNameUnsafe, getElementsByClassNameUnchecked,
         js_querySelector, querySelector, querySelector_,
-        querySelectorUnchecked, js_querySelectorAll, querySelectorAll,
-        querySelectorAll_, querySelectorAllUnchecked, js_matches, matches,
-        matches_, js_closest, closest, closest_, closestUnchecked,
+        querySelectorUnsafe, querySelectorUnchecked, js_querySelectorAll,
+        querySelectorAll, querySelectorAll_, querySelectorAllUnsafe,
+        querySelectorAllUnchecked, js_matches, matches, matches_,
+        js_closest, closest, closest_, closestUnsafe, closestUnchecked,
         js_webkitMatchesSelector, webkitMatchesSelector,
         webkitMatchesSelector_, js_getClientRects, getClientRects,
-        getClientRects_, getClientRectsUnchecked, js_getBoundingClientRect,
-        getBoundingClientRect, getBoundingClientRect_,
+        getClientRects_, getClientRectsUnsafe, getClientRectsUnchecked,
+        js_getBoundingClientRect, getBoundingClientRect,
+        getBoundingClientRect_, getBoundingClientRectUnsafe,
         getBoundingClientRectUnchecked, js_webkitRequestFullScreen,
         webkitRequestFullScreen, js_webkitRequestFullscreen,
         webkitRequestFullscreen, js_requestPointerLock, requestPointerLock,
         js_webkitGetRegionFlowRanges, webkitGetRegionFlowRanges,
         webkitGetRegionFlowRanges_, pattern ALLOW_KEYBOARD_INPUT,
-        js_getTagName, getTagName, getTagNameUnchecked, js_getAttributes,
-        getAttributes, getAttributesUnchecked, js_getStyle, getStyle,
+        js_getTagName, getTagName, getTagNameUnsafe, getTagNameUnchecked,
+        js_getAttributes, getAttributes, getAttributesUnsafe,
+        getAttributesUnchecked, js_getStyle, getStyle, getStyleUnsafe,
         getStyleUnchecked, js_setId, setId, js_getId, getId,
         js_getOffsetLeft, getOffsetLeft, js_getOffsetTop, getOffsetTop,
         js_getOffsetWidth, getOffsetWidth, js_getOffsetHeight,
@@ -49,35 +60,40 @@
         setScrollLeft, js_getScrollLeft, getScrollLeft, js_setScrollTop,
         setScrollTop, js_getScrollTop, getScrollTop, js_getScrollWidth,
         getScrollWidth, js_getScrollHeight, getScrollHeight,
-        js_getOffsetParent, getOffsetParent, getOffsetParentUnchecked,
-        js_setInnerHTML, setInnerHTML, js_getInnerHTML, getInnerHTML,
+        js_getOffsetParent, getOffsetParent, getOffsetParentUnsafe,
+        getOffsetParentUnchecked, js_setInnerHTML, setInnerHTML,
+        js_getInnerHTML, getInnerHTML, getInnerHTMLUnsafe,
         getInnerHTMLUnchecked, js_setOuterHTML, setOuterHTML,
-        js_getOuterHTML, getOuterHTML, getOuterHTMLUnchecked,
-        js_setClassName, setClassName, js_getClassName, getClassName,
-        js_getClassList, getClassList, getClassListUnchecked,
-        js_getDataset, getDataset, getDatasetUnchecked,
+        js_getOuterHTML, getOuterHTML, getOuterHTMLUnsafe,
+        getOuterHTMLUnchecked, js_setClassName, setClassName,
+        js_getClassName, getClassName, js_getClassList, getClassList,
+        getClassListUnsafe, getClassListUnchecked, js_getDataset,
+        getDataset, getDatasetUnsafe, getDatasetUnchecked,
         js_getFirstElementChild, getFirstElementChild,
-        getFirstElementChildUnchecked, js_getLastElementChild,
-        getLastElementChild, getLastElementChildUnchecked,
+        getFirstElementChildUnsafe, getFirstElementChildUnchecked,
+        js_getLastElementChild, getLastElementChild,
+        getLastElementChildUnsafe, getLastElementChildUnchecked,
         js_getPreviousElementSibling, getPreviousElementSibling,
+        getPreviousElementSiblingUnsafe,
         getPreviousElementSiblingUnchecked, js_getNextElementSibling,
-        getNextElementSibling, getNextElementSiblingUnchecked,
-        js_getChildElementCount, getChildElementCount, js_setUiactions,
-        setUiactions, js_getUiactions, getUiactions,
-        js_getWebkitRegionOverset, getWebkitRegionOverset, abort,
-        blurEvent, change, click, contextMenu, dblClick, drag, dragEnd,
-        dragEnter, dragLeave, dragOver, dragStart, drop, error, focusEvent,
-        input, invalid, keyDown, keyPress, keyUp, load, mouseDown,
-        mouseEnter, mouseLeave, mouseMove, mouseOut, mouseOver, mouseUp,
-        mouseWheel, scroll, select, submit, wheel, beforeCut, cut,
-        beforeCopy, copy, beforePaste, paste, reset, search, selectStart,
-        touchStart, touchMove, touchEnd, touchCancel,
-        webKitFullscreenChange, webKitFullscreenError,
-        webKitWillRevealBottom, webKitWillRevealLeft,
-        webKitWillRevealRight, webKitWillRevealTop, Element, castToElement,
-        gTypeElement, IsElement, toElement)
+        getNextElementSibling, getNextElementSiblingUnsafe,
+        getNextElementSiblingUnchecked, js_getChildElementCount,
+        getChildElementCount, js_setUiactions, setUiactions,
+        js_getUiactions, getUiactions, js_getWebkitRegionOverset,
+        getWebkitRegionOverset, abort, blurEvent, change, click,
+        contextMenu, dblClick, drag, dragEnd, dragEnter, dragLeave,
+        dragOver, dragStart, drop, error, focusEvent, input, invalid,
+        keyDown, keyPress, keyUp, load, mouseDown, mouseEnter, mouseLeave,
+        mouseMove, mouseOut, mouseOver, mouseUp, mouseWheel, scroll,
+        select, submit, wheel, beforeCut, cut, beforeCopy, copy,
+        beforePaste, paste, reset, search, selectStart, touchStart,
+        touchMove, touchEnd, touchCancel, webKitFullscreenChange,
+        webKitFullscreenError, webKitWillRevealBottom,
+        webKitWillRevealLeft, webKitWillRevealRight, webKitWillRevealTop,
+        Element(..), gTypeElement, IsElement, toElement)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -93,6 +109,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"getAttribute\"]($2)"
         js_getAttribute :: Element -> JSString -> IO (Nullable JSString)
@@ -116,6 +142,17 @@
       (void (js_getAttribute (toElement self) (toJSString name)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Element.getAttribute Mozilla Element.getAttribute documentation> 
+getAttributeUnsafe ::
+                   (MonadIO m, IsElement self, ToJSString name, HasCallStack,
+                    FromJSString result) =>
+                     self -> name -> m result
+getAttributeUnsafe self name
+  = liftIO
+      ((fromMaybeJSString <$>
+          (js_getAttribute (toElement self) (toJSString name)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Element.getAttribute Mozilla Element.getAttribute documentation> 
 getAttributeUnchecked ::
                       (MonadIO m, IsElement self, ToJSString name,
                        FromJSString result) =>
@@ -168,6 +205,16 @@
       (void (js_getAttributeNode (toElement self) (toJSString name)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Element.getAttributeNode Mozilla Element.getAttributeNode documentation> 
+getAttributeNodeUnsafe ::
+                       (MonadIO m, IsElement self, ToJSString name, HasCallStack) =>
+                         self -> name -> m Attr
+getAttributeNodeUnsafe self name
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_getAttributeNode (toElement self) (toJSString name)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Element.getAttributeNode Mozilla Element.getAttributeNode documentation> 
 getAttributeNodeUnchecked ::
                           (MonadIO m, IsElement self, ToJSString name) =>
                             self -> name -> m Attr
@@ -197,6 +244,16 @@
          (js_setAttributeNode (toElement self) (maybeToNullable newAttr)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Element.setAttributeNode Mozilla Element.setAttributeNode documentation> 
+setAttributeNodeUnsafe ::
+                       (MonadIO m, IsElement self, HasCallStack) =>
+                         self -> Maybe Attr -> m Attr
+setAttributeNodeUnsafe self newAttr
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_setAttributeNode (toElement self) (maybeToNullable newAttr)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Element.setAttributeNode Mozilla Element.setAttributeNode documentation> 
 setAttributeNodeUnchecked ::
                           (MonadIO m, IsElement self) => self -> Maybe Attr -> m Attr
 setAttributeNodeUnchecked self newAttr
@@ -227,6 +284,17 @@
             (maybeToNullable oldAttr)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Element.removeAttributeNode Mozilla Element.removeAttributeNode documentation> 
+removeAttributeNodeUnsafe ::
+                          (MonadIO m, IsElement self, HasCallStack) =>
+                            self -> Maybe Attr -> m Attr
+removeAttributeNodeUnsafe self oldAttr
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_removeAttributeNode (toElement self)
+             (maybeToNullable oldAttr)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Element.removeAttributeNode Mozilla Element.removeAttributeNode documentation> 
 removeAttributeNodeUnchecked ::
                              (MonadIO m, IsElement self) => self -> Maybe Attr -> m Attr
 removeAttributeNodeUnchecked self oldAttr
@@ -257,6 +325,16 @@
       (void (js_getElementsByTagName (toElement self) (toJSString name)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Element.getElementsByTagName Mozilla Element.getElementsByTagName documentation> 
+getElementsByTagNameUnsafe ::
+                           (MonadIO m, IsElement self, ToJSString name, HasCallStack) =>
+                             self -> name -> m NodeList
+getElementsByTagNameUnsafe self name
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_getElementsByTagName (toElement self) (toJSString name)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Element.getElementsByTagName Mozilla Element.getElementsByTagName documentation> 
 getElementsByTagNameUnchecked ::
                               (MonadIO m, IsElement self, ToJSString name) =>
                                 self -> name -> m NodeList
@@ -364,6 +442,19 @@
             (toJSString localName)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Element.getElementsByTagNameNS Mozilla Element.getElementsByTagNameNS documentation> 
+getElementsByTagNameNSUnsafe ::
+                             (MonadIO m, IsElement self, ToJSString namespaceURI,
+                              ToJSString localName, HasCallStack) =>
+                               self -> Maybe namespaceURI -> localName -> m NodeList
+getElementsByTagNameNSUnsafe self namespaceURI localName
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_getElementsByTagNameNS (toElement self)
+             (toMaybeJSString namespaceURI)
+             (toJSString localName)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Element.getElementsByTagNameNS Mozilla Element.getElementsByTagNameNS documentation> 
 getElementsByTagNameNSUnchecked ::
                                 (MonadIO m, IsElement self, ToJSString namespaceURI,
                                  ToJSString localName) =>
@@ -404,6 +495,19 @@
             (toJSString localName)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Element.getAttributeNodeNS Mozilla Element.getAttributeNodeNS documentation> 
+getAttributeNodeNSUnsafe ::
+                         (MonadIO m, IsElement self, ToJSString namespaceURI,
+                          ToJSString localName, HasCallStack) =>
+                           self -> Maybe namespaceURI -> localName -> m Attr
+getAttributeNodeNSUnsafe self namespaceURI localName
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_getAttributeNodeNS (toElement self)
+             (toMaybeJSString namespaceURI)
+             (toJSString localName)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Element.getAttributeNodeNS Mozilla Element.getAttributeNodeNS documentation> 
 getAttributeNodeNSUnchecked ::
                             (MonadIO m, IsElement self, ToJSString namespaceURI,
                              ToJSString localName) =>
@@ -436,6 +540,16 @@
          (js_setAttributeNodeNS (toElement self) (maybeToNullable newAttr)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Element.setAttributeNodeNS Mozilla Element.setAttributeNodeNS documentation> 
+setAttributeNodeNSUnsafe ::
+                         (MonadIO m, IsElement self, HasCallStack) =>
+                           self -> Maybe Attr -> m Attr
+setAttributeNodeNSUnsafe self newAttr
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_setAttributeNodeNS (toElement self) (maybeToNullable newAttr)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Element.setAttributeNodeNS Mozilla Element.setAttributeNodeNS documentation> 
 setAttributeNodeNSUnchecked ::
                             (MonadIO m, IsElement self) => self -> Maybe Attr -> m Attr
 setAttributeNodeNSUnchecked self newAttr
@@ -560,6 +674,16 @@
          (js_getElementsByClassName (toElement self) (toJSString name)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Element.getElementsByClassName Mozilla Element.getElementsByClassName documentation> 
+getElementsByClassNameUnsafe ::
+                             (MonadIO m, IsElement self, ToJSString name, HasCallStack) =>
+                               self -> name -> m NodeList
+getElementsByClassNameUnsafe self name
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_getElementsByClassName (toElement self) (toJSString name)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Element.getElementsByClassName Mozilla Element.getElementsByClassName documentation> 
 getElementsByClassNameUnchecked ::
                                 (MonadIO m, IsElement self, ToJSString name) =>
                                   self -> name -> m NodeList
@@ -589,6 +713,16 @@
       (void (js_querySelector (toElement self) (toJSString selectors)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Element.querySelector Mozilla Element.querySelector documentation> 
+querySelectorUnsafe ::
+                    (MonadIO m, IsElement self, ToJSString selectors, HasCallStack) =>
+                      self -> selectors -> m Element
+querySelectorUnsafe self selectors
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_querySelector (toElement self) (toJSString selectors)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Element.querySelector Mozilla Element.querySelector documentation> 
 querySelectorUnchecked ::
                        (MonadIO m, IsElement self, ToJSString selectors) =>
                          self -> selectors -> m Element
@@ -620,6 +754,16 @@
          (js_querySelectorAll (toElement self) (toJSString selectors)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Element.querySelectorAll Mozilla Element.querySelectorAll documentation> 
+querySelectorAllUnsafe ::
+                       (MonadIO m, IsElement self, ToJSString selectors, HasCallStack) =>
+                         self -> selectors -> m NodeList
+querySelectorAllUnsafe self selectors
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_querySelectorAll (toElement self) (toJSString selectors)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Element.querySelectorAll Mozilla Element.querySelectorAll documentation> 
 querySelectorAllUnchecked ::
                           (MonadIO m, IsElement self, ToJSString selectors) =>
                             self -> selectors -> m NodeList
@@ -667,6 +811,16 @@
       (void (js_closest (toElement self) (toJSString selectors)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Element.closest Mozilla Element.closest documentation> 
+closestUnsafe ::
+              (MonadIO m, IsElement self, ToJSString selectors, HasCallStack) =>
+                self -> selectors -> m Element
+closestUnsafe self selectors
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_closest (toElement self) (toJSString selectors)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Element.closest Mozilla Element.closest documentation> 
 closestUnchecked ::
                  (MonadIO m, IsElement self, ToJSString selectors) =>
                    self -> selectors -> m Element
@@ -711,6 +865,15 @@
   = liftIO (void (js_getClientRects (toElement self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Element.getClientRects Mozilla Element.getClientRects documentation> 
+getClientRectsUnsafe ::
+                     (MonadIO m, IsElement self, HasCallStack) =>
+                       self -> m ClientRectList
+getClientRectsUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getClientRects (toElement self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Element.getClientRects Mozilla Element.getClientRects documentation> 
 getClientRectsUnchecked ::
                         (MonadIO m, IsElement self) => self -> m ClientRectList
 getClientRectsUnchecked self
@@ -735,6 +898,14 @@
   = liftIO (void (js_getBoundingClientRect (toElement self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Element.getBoundingClientRect Mozilla Element.getBoundingClientRect documentation> 
+getBoundingClientRectUnsafe ::
+                            (MonadIO m, IsElement self, HasCallStack) => self -> m ClientRect
+getBoundingClientRectUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getBoundingClientRect (toElement self)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Element.getBoundingClientRect Mozilla Element.getBoundingClientRect documentation> 
 getBoundingClientRectUnchecked ::
                                (MonadIO m, IsElement self) => self -> m ClientRect
 getBoundingClientRectUnchecked self
@@ -800,6 +971,15 @@
   = liftIO (fromMaybeJSString <$> (js_getTagName (toElement self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Element.tagName Mozilla Element.tagName documentation> 
+getTagNameUnsafe ::
+                 (MonadIO m, IsElement self, HasCallStack, FromJSString result) =>
+                   self -> m result
+getTagNameUnsafe self
+  = liftIO
+      ((fromMaybeJSString <$> (js_getTagName (toElement self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Element.tagName Mozilla Element.tagName documentation> 
 getTagNameUnchecked ::
                     (MonadIO m, IsElement self, FromJSString result) =>
                       self -> m result
@@ -817,6 +997,14 @@
   = liftIO (nullableToMaybe <$> (js_getAttributes (toElement self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Element.attributes Mozilla Element.attributes documentation> 
+getAttributesUnsafe ::
+                    (MonadIO m, IsElement self, HasCallStack) => self -> m NamedNodeMap
+getAttributesUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getAttributes (toElement self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Element.attributes Mozilla Element.attributes documentation> 
 getAttributesUnchecked ::
                        (MonadIO m, IsElement self) => self -> m NamedNodeMap
 getAttributesUnchecked self
@@ -835,6 +1023,15 @@
   = liftIO (nullableToMaybe <$> (js_getStyle (toElement self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Element.style Mozilla Element.style documentation> 
+getStyleUnsafe ::
+               (MonadIO m, IsElement self, HasCallStack) =>
+                 self -> m CSSStyleDeclaration
+getStyleUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getStyle (toElement self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Element.style Mozilla Element.style documentation> 
 getStyleUnchecked ::
                   (MonadIO m, IsElement self) => self -> m CSSStyleDeclaration
 getStyleUnchecked self
@@ -970,6 +1167,14 @@
       (nullableToMaybe <$> (js_getOffsetParent (toElement self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Element.offsetParent Mozilla Element.offsetParent documentation> 
+getOffsetParentUnsafe ::
+                      (MonadIO m, IsElement self, HasCallStack) => self -> m Element
+getOffsetParentUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getOffsetParent (toElement self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Element.offsetParent Mozilla Element.offsetParent documentation> 
 getOffsetParentUnchecked ::
                          (MonadIO m, IsElement self) => self -> m Element
 getOffsetParentUnchecked self
@@ -998,6 +1203,15 @@
   = liftIO (fromMaybeJSString <$> (js_getInnerHTML (toElement self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Element.innerHTML Mozilla Element.innerHTML documentation> 
+getInnerHTMLUnsafe ::
+                   (MonadIO m, IsElement self, HasCallStack, FromJSString result) =>
+                     self -> m result
+getInnerHTMLUnsafe self
+  = liftIO
+      ((fromMaybeJSString <$> (js_getInnerHTML (toElement self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Element.innerHTML Mozilla Element.innerHTML documentation> 
 getInnerHTMLUnchecked ::
                       (MonadIO m, IsElement self, FromJSString result) =>
                         self -> m result
@@ -1027,6 +1241,15 @@
   = liftIO (fromMaybeJSString <$> (js_getOuterHTML (toElement self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Element.outerHTML Mozilla Element.outerHTML documentation> 
+getOuterHTMLUnsafe ::
+                   (MonadIO m, IsElement self, HasCallStack, FromJSString result) =>
+                     self -> m result
+getOuterHTMLUnsafe self
+  = liftIO
+      ((fromMaybeJSString <$> (js_getOuterHTML (toElement self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Element.outerHTML Mozilla Element.outerHTML documentation> 
 getOuterHTMLUnchecked ::
                       (MonadIO m, IsElement self, FromJSString result) =>
                         self -> m result
@@ -1064,6 +1287,14 @@
   = liftIO (nullableToMaybe <$> (js_getClassList (toElement self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Element.classList Mozilla Element.classList documentation> 
+getClassListUnsafe ::
+                   (MonadIO m, IsElement self, HasCallStack) => self -> m DOMTokenList
+getClassListUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getClassList (toElement self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Element.classList Mozilla Element.classList documentation> 
 getClassListUnchecked ::
                       (MonadIO m, IsElement self) => self -> m DOMTokenList
 getClassListUnchecked self
@@ -1080,6 +1311,14 @@
   = liftIO (nullableToMaybe <$> (js_getDataset (toElement self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Element.dataset Mozilla Element.dataset documentation> 
+getDatasetUnsafe ::
+                 (MonadIO m, IsElement self, HasCallStack) => self -> m DOMStringMap
+getDatasetUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getDataset (toElement self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Element.dataset Mozilla Element.dataset documentation> 
 getDatasetUnchecked ::
                     (MonadIO m, IsElement self) => self -> m DOMStringMap
 getDatasetUnchecked self
@@ -1097,6 +1336,14 @@
       (nullableToMaybe <$> (js_getFirstElementChild (toElement self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Element.firstElementChild Mozilla Element.firstElementChild documentation> 
+getFirstElementChildUnsafe ::
+                           (MonadIO m, IsElement self, HasCallStack) => self -> m Element
+getFirstElementChildUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getFirstElementChild (toElement self)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Element.firstElementChild Mozilla Element.firstElementChild documentation> 
 getFirstElementChildUnchecked ::
                               (MonadIO m, IsElement self) => self -> m Element
 getFirstElementChildUnchecked self
@@ -1115,6 +1362,14 @@
       (nullableToMaybe <$> (js_getLastElementChild (toElement self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Element.lastElementChild Mozilla Element.lastElementChild documentation> 
+getLastElementChildUnsafe ::
+                          (MonadIO m, IsElement self, HasCallStack) => self -> m Element
+getLastElementChildUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getLastElementChild (toElement self)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Element.lastElementChild Mozilla Element.lastElementChild documentation> 
 getLastElementChildUnchecked ::
                              (MonadIO m, IsElement self) => self -> m Element
 getLastElementChildUnchecked self
@@ -1134,6 +1389,15 @@
          (js_getPreviousElementSibling (toElement self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Element.previousElementSibling Mozilla Element.previousElementSibling documentation> 
+getPreviousElementSiblingUnsafe ::
+                                (MonadIO m, IsElement self, HasCallStack) => self -> m Element
+getPreviousElementSiblingUnsafe self
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_getPreviousElementSibling (toElement self)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Element.previousElementSibling Mozilla Element.previousElementSibling documentation> 
 getPreviousElementSiblingUnchecked ::
                                    (MonadIO m, IsElement self) => self -> m Element
 getPreviousElementSiblingUnchecked self
@@ -1150,6 +1414,14 @@
 getNextElementSibling self
   = liftIO
       (nullableToMaybe <$> (js_getNextElementSibling (toElement self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Element.nextElementSibling Mozilla Element.nextElementSibling documentation> 
+getNextElementSiblingUnsafe ::
+                            (MonadIO m, IsElement self, HasCallStack) => self -> m Element
+getNextElementSiblingUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getNextElementSibling (toElement self)))
+         >>= maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Element.nextElementSibling Mozilla Element.nextElementSibling documentation> 
 getNextElementSiblingUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/Entity.hs b/src/GHCJS/DOM/JSFFI/Generated/Entity.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/Entity.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/Entity.hs
@@ -1,11 +1,18 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.Entity
-       (js_getPublicId, getPublicId, getPublicIdUnchecked, js_getSystemId,
-        getSystemId, getSystemIdUnchecked, js_getNotationName,
-        getNotationName, getNotationNameUnchecked, Entity, castToEntity,
-        gTypeEntity)
+       (js_getPublicId, getPublicId, getPublicIdUnsafe,
+        getPublicIdUnchecked, js_getSystemId, getSystemId,
+        getSystemIdUnsafe, getSystemIdUnchecked, js_getNotationName,
+        getNotationName, getNotationNameUnsafe, getNotationNameUnchecked,
+        Entity(..), gTypeEntity)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -21,6 +28,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"publicId\"]" js_getPublicId
         :: Entity -> IO (Nullable JSString)
@@ -32,6 +49,15 @@
   = liftIO (fromMaybeJSString <$> (js_getPublicId (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Entity.publicId Mozilla Entity.publicId documentation> 
+getPublicIdUnsafe ::
+                  (MonadIO m, HasCallStack, FromJSString result) =>
+                    Entity -> m result
+getPublicIdUnsafe self
+  = liftIO
+      ((fromMaybeJSString <$> (js_getPublicId (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Entity.publicId Mozilla Entity.publicId documentation> 
 getPublicIdUnchecked ::
                      (MonadIO m, FromJSString result) => Entity -> m result
 getPublicIdUnchecked self
@@ -47,6 +73,15 @@
   = liftIO (fromMaybeJSString <$> (js_getSystemId (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Entity.systemId Mozilla Entity.systemId documentation> 
+getSystemIdUnsafe ::
+                  (MonadIO m, HasCallStack, FromJSString result) =>
+                    Entity -> m result
+getSystemIdUnsafe self
+  = liftIO
+      ((fromMaybeJSString <$> (js_getSystemId (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Entity.systemId Mozilla Entity.systemId documentation> 
 getSystemIdUnchecked ::
                      (MonadIO m, FromJSString result) => Entity -> m result
 getSystemIdUnchecked self
@@ -60,6 +95,15 @@
                 (MonadIO m, FromJSString result) => Entity -> m (Maybe result)
 getNotationName self
   = liftIO (fromMaybeJSString <$> (js_getNotationName (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Entity.notationName Mozilla Entity.notationName documentation> 
+getNotationNameUnsafe ::
+                      (MonadIO m, HasCallStack, FromJSString result) =>
+                        Entity -> m result
+getNotationNameUnsafe self
+  = liftIO
+      ((fromMaybeJSString <$> (js_getNotationName (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Entity.notationName Mozilla Entity.notationName documentation> 
 getNotationNameUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/Enums.hs b/src/GHCJS/DOM/JSFFI/Generated/Enums.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/Enums.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/Enums.hs
@@ -1,4 +1,9 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.Enums
        (KeyType(..), PToJSVal, ToJSVal, PFromJSVal, FromJSVal,
         js_KeyTypeSecret, js_KeyTypePublic, js_KeyTypePrivate,
@@ -45,6 +50,7 @@
         js_XMLHttpRequestResponseTypeText)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -58,6 +64,16 @@
 import Data.Maybe (fromJust)
 import GHCJS.DOM.Types
 import Control.Applicative ((<$>))
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 data KeyType = KeyTypeSecret
              | KeyTypePublic
diff --git a/src/GHCJS/DOM/JSFFI/Generated/ErrorEvent.hs b/src/GHCJS/DOM/JSFFI/Generated/ErrorEvent.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/ErrorEvent.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/ErrorEvent.hs
@@ -1,10 +1,16 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.ErrorEvent
        (js_getMessage, getMessage, js_getFilename, getFilename,
-        js_getLineno, getLineno, js_getColno, getColno, ErrorEvent,
-        castToErrorEvent, gTypeErrorEvent)
+        js_getLineno, getLineno, js_getColno, getColno, ErrorEvent(..),
+        gTypeErrorEvent)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -20,6 +26,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"message\"]" js_getMessage ::
         ErrorEvent -> IO JSString
diff --git a/src/GHCJS/DOM/JSFFI/Generated/Event.hs b/src/GHCJS/DOM/JSFFI/Generated/Event.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/Event.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/Event.hs
@@ -1,4 +1,9 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.Event
        (js_stopPropagation, stopPropagation, js_preventDefault,
         preventDefault, js_initEvent, initEvent,
@@ -9,19 +14,21 @@
         pattern MOUSEDRAG, pattern CLICK, pattern DBLCLICK,
         pattern KEYDOWN, pattern KEYUP, pattern KEYPRESS, pattern DRAGDROP,
         pattern FOCUS, pattern BLUR, pattern SELECT, pattern CHANGE,
-        js_getType, getType, js_getTarget, getTarget, getTargetUnchecked,
-        js_getCurrentTarget, getCurrentTarget, getCurrentTargetUnchecked,
+        js_getType, getType, js_getTarget, getTarget, getTargetUnsafe,
+        getTargetUnchecked, js_getCurrentTarget, getCurrentTarget,
+        getCurrentTargetUnsafe, getCurrentTargetUnchecked,
         js_getEventPhase, getEventPhase, js_getBubbles, getBubbles,
         js_getCancelable, getCancelable, js_getTimeStamp, getTimeStamp,
         js_getDefaultPrevented, getDefaultPrevented, js_getSrcElement,
-        getSrcElement, getSrcElementUnchecked, js_setReturnValue,
-        setReturnValue, js_getReturnValue, getReturnValue,
-        js_setCancelBubble, setCancelBubble, js_getCancelBubble,
-        getCancelBubble, js_getClipboardData, getClipboardData,
-        getClipboardDataUnchecked, Event, castToEvent, gTypeEvent, IsEvent,
-        toEvent)
+        getSrcElement, getSrcElementUnsafe, getSrcElementUnchecked,
+        js_setReturnValue, setReturnValue, js_getReturnValue,
+        getReturnValue, js_setCancelBubble, setCancelBubble,
+        js_getCancelBubble, getCancelBubble, js_getClipboardData,
+        getClipboardData, getClipboardDataUnsafe,
+        getClipboardDataUnchecked, Event(..), gTypeEvent, IsEvent, toEvent)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -36,6 +43,16 @@
 import GHCJS.DOM.Types
 import Control.Applicative ((<$>))
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"stopPropagation\"]()"
         js_stopPropagation :: Event -> IO ()
@@ -112,6 +129,14 @@
   = liftIO (nullableToMaybe <$> (js_getTarget (toEvent self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Event.target Mozilla Event.target documentation> 
+getTargetUnsafe ::
+                (MonadIO m, IsEvent self, HasCallStack) => self -> m EventTarget
+getTargetUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getTarget (toEvent self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Event.target Mozilla Event.target documentation> 
 getTargetUnchecked ::
                    (MonadIO m, IsEvent self) => self -> m EventTarget
 getTargetUnchecked self
@@ -128,6 +153,14 @@
   = liftIO (nullableToMaybe <$> (js_getCurrentTarget (toEvent self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Event.currentTarget Mozilla Event.currentTarget documentation> 
+getCurrentTargetUnsafe ::
+                       (MonadIO m, IsEvent self, HasCallStack) => self -> m EventTarget
+getCurrentTargetUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getCurrentTarget (toEvent self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Event.currentTarget Mozilla Event.currentTarget documentation> 
 getCurrentTargetUnchecked ::
                           (MonadIO m, IsEvent self) => self -> m EventTarget
 getCurrentTargetUnchecked self
@@ -182,6 +215,14 @@
   = liftIO (nullableToMaybe <$> (js_getSrcElement (toEvent self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Event.srcElement Mozilla Event.srcElement documentation> 
+getSrcElementUnsafe ::
+                    (MonadIO m, IsEvent self, HasCallStack) => self -> m EventTarget
+getSrcElementUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getSrcElement (toEvent self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Event.srcElement Mozilla Event.srcElement documentation> 
 getSrcElementUnchecked ::
                        (MonadIO m, IsEvent self) => self -> m EventTarget
 getSrcElementUnchecked self
@@ -227,6 +268,14 @@
                  (MonadIO m, IsEvent self) => self -> m (Maybe DataTransfer)
 getClipboardData self
   = liftIO (nullableToMaybe <$> (js_getClipboardData (toEvent self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Event.clipboardData Mozilla Event.clipboardData documentation> 
+getClipboardDataUnsafe ::
+                       (MonadIO m, IsEvent self, HasCallStack) => self -> m DataTransfer
+getClipboardDataUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getClipboardData (toEvent self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Event.clipboardData Mozilla Event.clipboardData documentation> 
 getClipboardDataUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/EventListener.hs b/src/GHCJS/DOM/JSFFI/Generated/EventListener.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/EventListener.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/EventListener.hs
@@ -1,9 +1,15 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.EventListener
-       (js_handleEvent, handleEvent, EventListener, castToEventListener,
+       (js_handleEvent, handleEvent, EventListener(..),
         gTypeEventListener)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -19,6 +25,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"handleEvent\"]($2)"
         js_handleEvent :: EventListener -> Nullable Event -> IO ()
diff --git a/src/GHCJS/DOM/JSFFI/Generated/EventSource.hs b/src/GHCJS/DOM/JSFFI/Generated/EventSource.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/EventSource.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/EventSource.hs
@@ -1,12 +1,18 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.EventSource
        (js_newEventSource, newEventSource, js_close, close,
         pattern CONNECTING, pattern OPEN, pattern CLOSED, js_getUrl,
         getUrl, js_getWithCredentials, getWithCredentials,
-        js_getReadyState, getReadyState, open, message, error, EventSource,
-        castToEventSource, gTypeEventSource)
+        js_getReadyState, getReadyState, open, message, error,
+        EventSource(..), gTypeEventSource)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -22,6 +28,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe
         "new window[\"EventSource\"]($1,\n$2)" js_newEventSource ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/EventTarget.hs b/src/GHCJS/DOM/JSFFI/Generated/EventTarget.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/EventTarget.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/EventTarget.hs
@@ -1,11 +1,17 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.EventTarget
        (js_addEventListener, addEventListener, js_removeEventListener,
         removeEventListener, js_dispatchEvent, dispatchEvent,
-        dispatchEvent_, EventTarget, castToEventTarget, gTypeEventTarget,
-        IsEventTarget, toEventTarget)
+        dispatchEvent_, EventTarget(..), gTypeEventTarget, IsEventTarget,
+        toEventTarget)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -20,6 +26,16 @@
 import GHCJS.DOM.Types
 import Control.Applicative ((<$>))
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe
         "$1[\"addEventListener\"]($2, $3,\n$4)" js_addEventListener ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/File.hs b/src/GHCJS/DOM/JSFFI/Generated/File.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/File.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/File.hs
@@ -1,9 +1,16 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.File
        (js_getName, getName, js_getLastModifiedDate, getLastModifiedDate,
-        getLastModifiedDateUnchecked, File, castToFile, gTypeFile)
+        getLastModifiedDateUnsafe, getLastModifiedDateUnchecked, File(..),
+        gTypeFile)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -19,6 +26,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"name\"]" js_getName ::
         File -> IO JSString
@@ -34,6 +51,14 @@
 getLastModifiedDate :: (MonadIO m) => File -> m (Maybe Date)
 getLastModifiedDate self
   = liftIO (nullableToMaybe <$> (js_getLastModifiedDate (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/File.lastModifiedDate Mozilla File.lastModifiedDate documentation> 
+getLastModifiedDateUnsafe ::
+                          (MonadIO m, HasCallStack) => File -> m Date
+getLastModifiedDateUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getLastModifiedDate (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/File.lastModifiedDate Mozilla File.lastModifiedDate documentation> 
 getLastModifiedDateUnchecked :: (MonadIO m) => File -> m Date
diff --git a/src/GHCJS/DOM/JSFFI/Generated/FileError.hs b/src/GHCJS/DOM/JSFFI/Generated/FileError.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/FileError.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/FileError.hs
@@ -1,14 +1,20 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.FileError
        (pattern NOT_FOUND_ERR, pattern SECURITY_ERR, pattern ABORT_ERR,
         pattern NOT_READABLE_ERR, pattern ENCODING_ERR,
         pattern NO_MODIFICATION_ALLOWED_ERR, pattern INVALID_STATE_ERR,
         pattern SYNTAX_ERR, pattern INVALID_MODIFICATION_ERR,
         pattern QUOTA_EXCEEDED_ERR, pattern TYPE_MISMATCH_ERR,
-        pattern PATH_EXISTS_ERR, js_getCode, getCode, FileError,
-        castToFileError, gTypeFileError)
+        pattern PATH_EXISTS_ERR, js_getCode, getCode, FileError(..),
+        gTypeFileError)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -24,6 +30,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
 pattern NOT_FOUND_ERR = 1
 pattern SECURITY_ERR = 2
 pattern ABORT_ERR = 3
diff --git a/src/GHCJS/DOM/JSFFI/Generated/FileList.hs b/src/GHCJS/DOM/JSFFI/Generated/FileList.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/FileList.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/FileList.hs
@@ -1,9 +1,15 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.FileList
-       (js_item, item, item_, itemUnchecked, js_getLength, getLength,
-        FileList, castToFileList, gTypeFileList)
+       (js_item, item, item_, itemUnsafe, itemUnchecked, js_getLength,
+        getLength, FileList(..), gTypeFileList)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -19,6 +25,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"item\"]($2)" js_item ::
         FileList -> Word -> IO (Nullable File)
@@ -31,6 +47,14 @@
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/FileList.item Mozilla FileList.item documentation> 
 item_ :: (MonadIO m) => FileList -> Word -> m ()
 item_ self index = liftIO (void (js_item (self) index))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/FileList.item Mozilla FileList.item documentation> 
+itemUnsafe ::
+           (MonadIO m, HasCallStack) => FileList -> Word -> m File
+itemUnsafe self index
+  = liftIO
+      ((nullableToMaybe <$> (js_item (self) index)) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/FileList.item Mozilla FileList.item documentation> 
 itemUnchecked :: (MonadIO m) => FileList -> Word -> m File
diff --git a/src/GHCJS/DOM/JSFFI/Generated/FileReader.hs b/src/GHCJS/DOM/JSFFI/Generated/FileReader.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/FileReader.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/FileReader.hs
@@ -1,15 +1,21 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.FileReader
        (js_newFileReader, newFileReader, js_readAsArrayBuffer,
         readAsArrayBuffer, js_readAsBinaryString, readAsBinaryString,
         js_readAsText, readAsText, js_readAsDataURL, readAsDataURL,
         js_abort, abort, pattern EMPTY, pattern LOADING, pattern DONE,
         js_getReadyState, getReadyState, js_getResult, getResult,
-        js_getError, getError, getErrorUnchecked, loadStart, progress,
-        load, abortEvent, error, loadEnd, FileReader, castToFileReader,
-        gTypeFileReader)
+        js_getError, getError, getErrorUnsafe, getErrorUnchecked,
+        loadStart, progress, load, abortEvent, error, loadEnd,
+        FileReader(..), gTypeFileReader)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -25,6 +31,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "new window[\"FileReader\"]()"
         js_newFileReader :: IO FileReader
@@ -105,6 +121,14 @@
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/FileReader.error Mozilla FileReader.error documentation> 
 getError :: (MonadIO m) => FileReader -> m (Maybe FileError)
 getError self = liftIO (nullableToMaybe <$> (js_getError (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/FileReader.error Mozilla FileReader.error documentation> 
+getErrorUnsafe ::
+               (MonadIO m, HasCallStack) => FileReader -> m FileError
+getErrorUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getError (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/FileReader.error Mozilla FileReader.error documentation> 
 getErrorUnchecked :: (MonadIO m) => FileReader -> m FileError
diff --git a/src/GHCJS/DOM/JSFFI/Generated/FileReaderSync.hs b/src/GHCJS/DOM/JSFFI/Generated/FileReaderSync.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/FileReaderSync.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/FileReaderSync.hs
@@ -1,13 +1,19 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.FileReaderSync
        (js_newFileReaderSync, newFileReaderSync, js_readAsArrayBuffer,
-        readAsArrayBuffer, readAsArrayBuffer_, readAsArrayBufferUnchecked,
-        js_readAsBinaryString, readAsBinaryString, readAsBinaryString_,
-        js_readAsText, readAsText, readAsText_, js_readAsDataURL,
-        readAsDataURL, readAsDataURL_, FileReaderSync,
-        castToFileReaderSync, gTypeFileReaderSync)
+        readAsArrayBuffer, readAsArrayBuffer_, readAsArrayBufferUnsafe,
+        readAsArrayBufferUnchecked, js_readAsBinaryString,
+        readAsBinaryString, readAsBinaryString_, js_readAsText, readAsText,
+        readAsText_, js_readAsDataURL, readAsDataURL, readAsDataURL_,
+        FileReaderSync(..), gTypeFileReaderSync)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -23,6 +29,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "new window[\"FileReaderSync\"]()"
         js_newFileReaderSync :: IO FileReaderSync
@@ -51,6 +67,16 @@
   = liftIO
       (void
          (js_readAsArrayBuffer (self) (maybeToNullable (fmap toBlob blob))))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/FileReaderSync.readAsArrayBuffer Mozilla FileReaderSync.readAsArrayBuffer documentation> 
+readAsArrayBufferUnsafe ::
+                        (MonadIO m, IsBlob blob, HasCallStack) =>
+                          FileReaderSync -> Maybe blob -> m ArrayBuffer
+readAsArrayBufferUnsafe self blob
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_readAsArrayBuffer (self) (maybeToNullable (fmap toBlob blob))))
+         >>= maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/FileReaderSync.readAsArrayBuffer Mozilla FileReaderSync.readAsArrayBuffer documentation> 
 readAsArrayBufferUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/FocusEvent.hs b/src/GHCJS/DOM/JSFFI/Generated/FocusEvent.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/FocusEvent.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/FocusEvent.hs
@@ -1,9 +1,15 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.FocusEvent
-       (js_getRelatedTarget, getRelatedTarget, getRelatedTargetUnchecked,
-        FocusEvent, castToFocusEvent, gTypeFocusEvent)
+       (js_getRelatedTarget, getRelatedTarget, getRelatedTargetUnsafe,
+        getRelatedTargetUnchecked, FocusEvent(..), gTypeFocusEvent)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -19,6 +25,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"relatedTarget\"]"
         js_getRelatedTarget :: FocusEvent -> IO (Nullable EventTarget)
@@ -28,6 +44,14 @@
                  (MonadIO m) => FocusEvent -> m (Maybe EventTarget)
 getRelatedTarget self
   = liftIO (nullableToMaybe <$> (js_getRelatedTarget (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/FocusEvent.relatedTarget Mozilla FocusEvent.relatedTarget documentation> 
+getRelatedTargetUnsafe ::
+                       (MonadIO m, HasCallStack) => FocusEvent -> m EventTarget
+getRelatedTargetUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getRelatedTarget (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/FocusEvent.relatedTarget Mozilla FocusEvent.relatedTarget documentation> 
 getRelatedTargetUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/FontLoader.hs b/src/GHCJS/DOM/JSFFI/Generated/FontLoader.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/FontLoader.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/FontLoader.hs
@@ -1,11 +1,17 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.FontLoader
        (js_checkFont, checkFont, checkFont_, js_loadFont, loadFont,
         js_notifyWhenFontsReady, notifyWhenFontsReady, loading,
         loadingDone, loadStart, load, error, js_getLoading, getLoading,
-        FontLoader, castToFontLoader, gTypeFontLoader)
+        FontLoader(..), gTypeFontLoader)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -21,6 +27,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe
         "($1[\"checkFont\"]($2,\n$3) ? 1 : 0)" js_checkFont ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/FormData.hs b/src/GHCJS/DOM/JSFFI/Generated/FormData.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/FormData.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/FormData.hs
@@ -1,9 +1,15 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.FormData
-       (js_newFormData, newFormData, js_append, append, FormData,
-        castToFormData, gTypeFormData)
+       (js_newFormData, newFormData, js_append, append, FormData(..),
+        gTypeFormData)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -19,6 +25,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "new window[\"FormData\"]($1)"
         js_newFormData :: Nullable HTMLFormElement -> IO FormData
diff --git a/src/GHCJS/DOM/JSFFI/Generated/GainNode.hs b/src/GHCJS/DOM/JSFFI/Generated/GainNode.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/GainNode.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/GainNode.hs
@@ -1,9 +1,15 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.GainNode
-       (js_getGain, getGain, getGainUnchecked, GainNode, castToGainNode,
-        gTypeGainNode)
+       (js_getGain, getGain, getGainUnsafe, getGainUnchecked,
+        GainNode(..), gTypeGainNode)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -19,6 +25,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"gain\"]" js_getGain ::
         GainNode -> IO (Nullable AudioParam)
@@ -26,6 +42,14 @@
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/GainNode.gain Mozilla GainNode.gain documentation> 
 getGain :: (MonadIO m) => GainNode -> m (Maybe AudioParam)
 getGain self = liftIO (nullableToMaybe <$> (js_getGain (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/GainNode.gain Mozilla GainNode.gain documentation> 
+getGainUnsafe ::
+              (MonadIO m, HasCallStack) => GainNode -> m AudioParam
+getGainUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getGain (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/GainNode.gain Mozilla GainNode.gain documentation> 
 getGainUnchecked :: (MonadIO m) => GainNode -> m AudioParam
diff --git a/src/GHCJS/DOM/JSFFI/Generated/Gamepad.hs b/src/GHCJS/DOM/JSFFI/Generated/Gamepad.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/Gamepad.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/Gamepad.hs
@@ -1,11 +1,17 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.Gamepad
        (js_getId, getId, js_getIndex, getIndex, js_getConnected,
         getConnected, js_getTimestamp, getTimestamp, js_getMapping,
         getMapping, js_getAxes, getAxes, js_getButtons, getButtons,
-        Gamepad, castToGamepad, gTypeGamepad)
+        Gamepad(..), gTypeGamepad)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -21,6 +27,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"id\"]" js_getId ::
         Gamepad -> IO JSString
diff --git a/src/GHCJS/DOM/JSFFI/Generated/GamepadButton.hs b/src/GHCJS/DOM/JSFFI/Generated/GamepadButton.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/GamepadButton.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/GamepadButton.hs
@@ -1,9 +1,15 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.GamepadButton
-       (js_getPressed, getPressed, js_getValue, getValue, GamepadButton,
-        castToGamepadButton, gTypeGamepadButton)
+       (js_getPressed, getPressed, js_getValue, getValue,
+        GamepadButton(..), gTypeGamepadButton)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -19,6 +25,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "($1[\"pressed\"] ? 1 : 0)"
         js_getPressed :: GamepadButton -> IO Bool
diff --git a/src/GHCJS/DOM/JSFFI/Generated/GamepadEvent.hs b/src/GHCJS/DOM/JSFFI/Generated/GamepadEvent.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/GamepadEvent.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/GamepadEvent.hs
@@ -1,9 +1,15 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.GamepadEvent
-       (js_getGamepad, getGamepad, getGamepadUnchecked, GamepadEvent,
-        castToGamepadEvent, gTypeGamepadEvent)
+       (js_getGamepad, getGamepad, getGamepadUnsafe, getGamepadUnchecked,
+        GamepadEvent(..), gTypeGamepadEvent)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -19,6 +25,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"gamepad\"]" js_getGamepad ::
         GamepadEvent -> IO (Nullable Gamepad)
@@ -27,6 +43,14 @@
 getGamepad :: (MonadIO m) => GamepadEvent -> m (Maybe Gamepad)
 getGamepad self
   = liftIO (nullableToMaybe <$> (js_getGamepad (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/GamepadEvent.gamepad Mozilla GamepadEvent.gamepad documentation> 
+getGamepadUnsafe ::
+                 (MonadIO m, HasCallStack) => GamepadEvent -> m Gamepad
+getGamepadUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getGamepad (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/GamepadEvent.gamepad Mozilla GamepadEvent.gamepad documentation> 
 getGamepadUnchecked :: (MonadIO m) => GamepadEvent -> m Gamepad
diff --git a/src/GHCJS/DOM/JSFFI/Generated/Geolocation.hs b/src/GHCJS/DOM/JSFFI/Generated/Geolocation.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/Geolocation.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/Geolocation.hs
@@ -1,10 +1,16 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.Geolocation
        (js_getCurrentPosition, getCurrentPosition, js_watchPosition,
         watchPosition, watchPosition_, js_clearWatch, clearWatch,
-        Geolocation, castToGeolocation, gTypeGeolocation)
+        Geolocation(..), gTypeGeolocation)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -20,6 +26,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe
         "$1[\"getCurrentPosition\"]($2, $3,\n$4)" js_getCurrentPosition ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/Geoposition.hs b/src/GHCJS/DOM/JSFFI/Generated/Geoposition.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/Geoposition.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/Geoposition.hs
@@ -1,9 +1,15 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.Geoposition
-       (js_getCoords, getCoords, getCoordsUnchecked, js_getTimestamp,
-        getTimestamp, Geoposition, castToGeoposition, gTypeGeoposition)
+       (js_getCoords, getCoords, getCoordsUnsafe, getCoordsUnchecked,
+        js_getTimestamp, getTimestamp, Geoposition(..), gTypeGeoposition)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -19,6 +25,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"coords\"]" js_getCoords ::
         Geoposition -> IO (Nullable Coordinates)
@@ -26,6 +42,14 @@
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Geoposition.coords Mozilla Geoposition.coords documentation> 
 getCoords :: (MonadIO m) => Geoposition -> m (Maybe Coordinates)
 getCoords self = liftIO (nullableToMaybe <$> (js_getCoords (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Geoposition.coords Mozilla Geoposition.coords documentation> 
+getCoordsUnsafe ::
+                (MonadIO m, HasCallStack) => Geoposition -> m Coordinates
+getCoordsUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getCoords (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Geoposition.coords Mozilla Geoposition.coords documentation> 
 getCoordsUnchecked :: (MonadIO m) => Geoposition -> m Coordinates
diff --git a/src/GHCJS/DOM/JSFFI/Generated/HTMLAllCollection.hs b/src/GHCJS/DOM/JSFFI/Generated/HTMLAllCollection.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/HTMLAllCollection.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/HTMLAllCollection.hs
@@ -1,11 +1,17 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.HTMLAllCollection
-       (js_item, item, item_, itemUnchecked, js_namedItem, namedItem,
-        namedItem_, namedItemUnchecked, js_tags, tags, tags_,
-        tagsUnchecked, js_getLength, getLength, HTMLAllCollection,
-        castToHTMLAllCollection, gTypeHTMLAllCollection)
+       (js_item, item, item_, itemUnsafe, itemUnchecked, js_namedItem,
+        namedItem, namedItem_, namedItemUnsafe, namedItemUnchecked,
+        js_tags, tags, tags_, tagsUnsafe, tagsUnchecked, js_getLength,
+        getLength, HTMLAllCollection(..), gTypeHTMLAllCollection)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -21,6 +27,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"item\"]($2)" js_item ::
         HTMLAllCollection -> Word -> IO (Nullable Node)
@@ -35,6 +51,14 @@
 item_ self index = liftIO (void (js_item (self) index))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLAllCollection.item Mozilla HTMLAllCollection.item documentation> 
+itemUnsafe ::
+           (MonadIO m, HasCallStack) => HTMLAllCollection -> Word -> m Node
+itemUnsafe self index
+  = liftIO
+      ((nullableToMaybe <$> (js_item (self) index)) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLAllCollection.item Mozilla HTMLAllCollection.item documentation> 
 itemUnchecked :: (MonadIO m) => HTMLAllCollection -> Word -> m Node
 itemUnchecked self index
   = liftIO (fromJust . nullableToMaybe <$> (js_item (self) index))
@@ -57,6 +81,15 @@
   = liftIO (void (js_namedItem (self) (toJSString name)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLAllCollection.namedItem Mozilla HTMLAllCollection.namedItem documentation> 
+namedItemUnsafe ::
+                (MonadIO m, ToJSString name, HasCallStack) =>
+                  HTMLAllCollection -> name -> m Node
+namedItemUnsafe self name
+  = liftIO
+      ((nullableToMaybe <$> (js_namedItem (self) (toJSString name))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLAllCollection.namedItem Mozilla HTMLAllCollection.namedItem documentation> 
 namedItemUnchecked ::
                    (MonadIO m, ToJSString name) => HTMLAllCollection -> name -> m Node
 namedItemUnchecked self name
@@ -78,6 +111,15 @@
 tags_ ::
       (MonadIO m, ToJSString name) => HTMLAllCollection -> name -> m ()
 tags_ self name = liftIO (void (js_tags (self) (toJSString name)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLAllCollection.tags Mozilla HTMLAllCollection.tags documentation> 
+tagsUnsafe ::
+           (MonadIO m, ToJSString name, HasCallStack) =>
+             HTMLAllCollection -> name -> m NodeList
+tagsUnsafe self name
+  = liftIO
+      ((nullableToMaybe <$> (js_tags (self) (toJSString name))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLAllCollection.tags Mozilla HTMLAllCollection.tags documentation> 
 tagsUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/HTMLAnchorElement.hs b/src/GHCJS/DOM/JSFFI/Generated/HTMLAnchorElement.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/HTMLAnchorElement.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/HTMLAnchorElement.hs
@@ -1,4 +1,9 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.HTMLAnchorElement
        (js_toString, toString, toString_, js_setCharset, setCharset,
         js_getCharset, getCharset, js_setCoords, setCoords, js_getCoords,
@@ -10,19 +15,23 @@
         js_setRev, setRev, js_getRev, getRev, js_setShape, setShape,
         js_getShape, getShape, js_setTarget, setTarget, js_getTarget,
         getTarget, js_setType, setType, js_getType, getType, js_setHash,
-        setHash, js_getHash, getHash, getHashUnchecked, js_setHost,
-        setHost, js_getHost, getHost, getHostUnchecked, js_setHostname,
-        setHostname, js_getHostname, getHostname, getHostnameUnchecked,
+        setHash, js_getHash, getHash, getHashUnsafe, getHashUnchecked,
+        js_setHost, setHost, js_getHost, getHost, getHostUnsafe,
+        getHostUnchecked, js_setHostname, setHostname, js_getHostname,
+        getHostname, getHostnameUnsafe, getHostnameUnchecked,
         js_setPathname, setPathname, js_getPathname, getPathname,
-        getPathnameUnchecked, js_setPort, setPort, js_getPort, getPort,
-        getPortUnchecked, js_setProtocol, setProtocol, js_getProtocol,
-        getProtocol, getProtocolUnchecked, js_setSearch, setSearch,
-        js_getSearch, getSearch, getSearchUnchecked, js_getOrigin,
-        getOrigin, getOriginUnchecked, js_setText, setText, js_getText,
-        getText, js_getRelList, getRelList, getRelListUnchecked,
-        HTMLAnchorElement, castToHTMLAnchorElement, gTypeHTMLAnchorElement)
+        getPathnameUnsafe, getPathnameUnchecked, js_setPort, setPort,
+        js_getPort, getPort, getPortUnsafe, getPortUnchecked,
+        js_setProtocol, setProtocol, js_getProtocol, getProtocol,
+        getProtocolUnsafe, getProtocolUnchecked, js_setSearch, setSearch,
+        js_getSearch, getSearch, getSearchUnsafe, getSearchUnchecked,
+        js_getOrigin, getOrigin, getOriginUnsafe, getOriginUnchecked,
+        js_setText, setText, js_getText, getText, js_getRelList,
+        getRelList, getRelListUnsafe, getRelListUnchecked,
+        HTMLAnchorElement(..), gTypeHTMLAnchorElement)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -38,6 +47,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"toString\"]()" js_toString
         :: HTMLAnchorElement -> IO JSString
@@ -267,6 +286,15 @@
 getHash self = liftIO (fromMaybeJSString <$> (js_getHash (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLAnchorElement.hash Mozilla HTMLAnchorElement.hash documentation> 
+getHashUnsafe ::
+              (MonadIO m, HasCallStack, FromJSString result) =>
+                HTMLAnchorElement -> m result
+getHashUnsafe self
+  = liftIO
+      ((fromMaybeJSString <$> (js_getHash (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLAnchorElement.hash Mozilla HTMLAnchorElement.hash documentation> 
 getHashUnchecked ::
                  (MonadIO m, FromJSString result) => HTMLAnchorElement -> m result
 getHashUnchecked self
@@ -291,6 +319,15 @@
 getHost self = liftIO (fromMaybeJSString <$> (js_getHost (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLAnchorElement.host Mozilla HTMLAnchorElement.host documentation> 
+getHostUnsafe ::
+              (MonadIO m, HasCallStack, FromJSString result) =>
+                HTMLAnchorElement -> m result
+getHostUnsafe self
+  = liftIO
+      ((fromMaybeJSString <$> (js_getHost (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLAnchorElement.host Mozilla HTMLAnchorElement.host documentation> 
 getHostUnchecked ::
                  (MonadIO m, FromJSString result) => HTMLAnchorElement -> m result
 getHostUnchecked self
@@ -317,6 +354,15 @@
   = liftIO (fromMaybeJSString <$> (js_getHostname (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLAnchorElement.hostname Mozilla HTMLAnchorElement.hostname documentation> 
+getHostnameUnsafe ::
+                  (MonadIO m, HasCallStack, FromJSString result) =>
+                    HTMLAnchorElement -> m result
+getHostnameUnsafe self
+  = liftIO
+      ((fromMaybeJSString <$> (js_getHostname (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLAnchorElement.hostname Mozilla HTMLAnchorElement.hostname documentation> 
 getHostnameUnchecked ::
                      (MonadIO m, FromJSString result) => HTMLAnchorElement -> m result
 getHostnameUnchecked self
@@ -343,6 +389,15 @@
   = liftIO (fromMaybeJSString <$> (js_getPathname (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLAnchorElement.pathname Mozilla HTMLAnchorElement.pathname documentation> 
+getPathnameUnsafe ::
+                  (MonadIO m, HasCallStack, FromJSString result) =>
+                    HTMLAnchorElement -> m result
+getPathnameUnsafe self
+  = liftIO
+      ((fromMaybeJSString <$> (js_getPathname (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLAnchorElement.pathname Mozilla HTMLAnchorElement.pathname documentation> 
 getPathnameUnchecked ::
                      (MonadIO m, FromJSString result) => HTMLAnchorElement -> m result
 getPathnameUnchecked self
@@ -367,6 +422,15 @@
 getPort self = liftIO (fromMaybeJSString <$> (js_getPort (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLAnchorElement.port Mozilla HTMLAnchorElement.port documentation> 
+getPortUnsafe ::
+              (MonadIO m, HasCallStack, FromJSString result) =>
+                HTMLAnchorElement -> m result
+getPortUnsafe self
+  = liftIO
+      ((fromMaybeJSString <$> (js_getPort (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLAnchorElement.port Mozilla HTMLAnchorElement.port documentation> 
 getPortUnchecked ::
                  (MonadIO m, FromJSString result) => HTMLAnchorElement -> m result
 getPortUnchecked self
@@ -393,6 +457,15 @@
   = liftIO (fromMaybeJSString <$> (js_getProtocol (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLAnchorElement.protocol Mozilla HTMLAnchorElement.protocol documentation> 
+getProtocolUnsafe ::
+                  (MonadIO m, HasCallStack, FromJSString result) =>
+                    HTMLAnchorElement -> m result
+getProtocolUnsafe self
+  = liftIO
+      ((fromMaybeJSString <$> (js_getProtocol (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLAnchorElement.protocol Mozilla HTMLAnchorElement.protocol documentation> 
 getProtocolUnchecked ::
                      (MonadIO m, FromJSString result) => HTMLAnchorElement -> m result
 getProtocolUnchecked self
@@ -419,6 +492,15 @@
   = liftIO (fromMaybeJSString <$> (js_getSearch (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLAnchorElement.search Mozilla HTMLAnchorElement.search documentation> 
+getSearchUnsafe ::
+                (MonadIO m, HasCallStack, FromJSString result) =>
+                  HTMLAnchorElement -> m result
+getSearchUnsafe self
+  = liftIO
+      ((fromMaybeJSString <$> (js_getSearch (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLAnchorElement.search Mozilla HTMLAnchorElement.search documentation> 
 getSearchUnchecked ::
                    (MonadIO m, FromJSString result) => HTMLAnchorElement -> m result
 getSearchUnchecked self
@@ -435,6 +517,15 @@
   = liftIO (fromMaybeJSString <$> (js_getOrigin (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLAnchorElement.origin Mozilla HTMLAnchorElement.origin documentation> 
+getOriginUnsafe ::
+                (MonadIO m, HasCallStack, FromJSString result) =>
+                  HTMLAnchorElement -> m result
+getOriginUnsafe self
+  = liftIO
+      ((fromMaybeJSString <$> (js_getOrigin (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLAnchorElement.origin Mozilla HTMLAnchorElement.origin documentation> 
 getOriginUnchecked ::
                    (MonadIO m, FromJSString result) => HTMLAnchorElement -> m result
 getOriginUnchecked self
@@ -464,6 +555,14 @@
            (MonadIO m) => HTMLAnchorElement -> m (Maybe DOMTokenList)
 getRelList self
   = liftIO (nullableToMaybe <$> (js_getRelList (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLAnchorElement.relList Mozilla HTMLAnchorElement.relList documentation> 
+getRelListUnsafe ::
+                 (MonadIO m, HasCallStack) => HTMLAnchorElement -> m DOMTokenList
+getRelListUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getRelList (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLAnchorElement.relList Mozilla HTMLAnchorElement.relList documentation> 
 getRelListUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/HTMLAppletElement.hs b/src/GHCJS/DOM/JSFFI/Generated/HTMLAppletElement.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/HTMLAppletElement.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/HTMLAppletElement.hs
@@ -1,4 +1,9 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.HTMLAppletElement
        (js_setAlign, setAlign, js_getAlign, getAlign, js_setAlt, setAlt,
         js_getAlt, getAlt, js_setArchive, setArchive, js_getArchive,
@@ -8,10 +13,11 @@
         setHspace, js_getHspace, getHspace, js_setName, setName,
         js_getName, getName, js_setObject, setObject, js_getObject,
         getObject, js_setVspace, setVspace, js_getVspace, getVspace,
-        js_setWidth, setWidth, js_getWidth, getWidth, HTMLAppletElement,
-        castToHTMLAppletElement, gTypeHTMLAppletElement)
+        js_setWidth, setWidth, js_getWidth, getWidth,
+        HTMLAppletElement(..), gTypeHTMLAppletElement)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -27,6 +33,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"align\"] = $2;" js_setAlign
         :: HTMLAppletElement -> JSString -> IO ()
diff --git a/src/GHCJS/DOM/JSFFI/Generated/HTMLAreaElement.hs b/src/GHCJS/DOM/JSFFI/Generated/HTMLAreaElement.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/HTMLAreaElement.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/HTMLAreaElement.hs
@@ -1,4 +1,9 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.HTMLAreaElement
        (js_setAlt, setAlt, js_getAlt, getAlt, js_setCoords, setCoords,
         js_getCoords, getCoords, js_setHref, setHref, js_getHref, getHref,
@@ -9,10 +14,11 @@
         js_getHost, getHost, js_getHostname, getHostname, js_getPathname,
         getPathname, js_getPort, getPort, js_getProtocol, getProtocol,
         js_getSearch, getSearch, js_getRelList, getRelList,
-        getRelListUnchecked, HTMLAreaElement, castToHTMLAreaElement,
+        getRelListUnsafe, getRelListUnchecked, HTMLAreaElement(..),
         gTypeHTMLAreaElement)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -28,6 +34,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"alt\"] = $2;" js_setAlt ::
         HTMLAreaElement -> JSString -> IO ()
@@ -222,6 +238,14 @@
            (MonadIO m) => HTMLAreaElement -> m (Maybe DOMTokenList)
 getRelList self
   = liftIO (nullableToMaybe <$> (js_getRelList (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLAreaElement.relList Mozilla HTMLAreaElement.relList documentation> 
+getRelListUnsafe ::
+                 (MonadIO m, HasCallStack) => HTMLAreaElement -> m DOMTokenList
+getRelListUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getRelList (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLAreaElement.relList Mozilla HTMLAreaElement.relList documentation> 
 getRelListUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/HTMLBRElement.hs b/src/GHCJS/DOM/JSFFI/Generated/HTMLBRElement.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/HTMLBRElement.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/HTMLBRElement.hs
@@ -1,9 +1,15 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.HTMLBRElement
-       (js_setClear, setClear, js_getClear, getClear, HTMLBRElement,
-        castToHTMLBRElement, gTypeHTMLBRElement)
+       (js_setClear, setClear, js_getClear, getClear, HTMLBRElement(..),
+        gTypeHTMLBRElement)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -19,6 +25,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"clear\"] = $2;" js_setClear
         :: HTMLBRElement -> JSString -> IO ()
diff --git a/src/GHCJS/DOM/JSFFI/Generated/HTMLBaseElement.hs b/src/GHCJS/DOM/JSFFI/Generated/HTMLBaseElement.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/HTMLBaseElement.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/HTMLBaseElement.hs
@@ -1,10 +1,16 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.HTMLBaseElement
-       (js_setHref, setHref, js_getHref, getHref, getHrefUnchecked,
-        js_setTarget, setTarget, js_getTarget, getTarget, HTMLBaseElement,
-        castToHTMLBaseElement, gTypeHTMLBaseElement)
+       (js_setHref, setHref, js_getHref, getHref, getHrefUnsafe,
+        getHrefUnchecked, js_setTarget, setTarget, js_getTarget, getTarget,
+        HTMLBaseElement(..), gTypeHTMLBaseElement)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -20,6 +26,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"href\"] = $2;" js_setHref ::
         HTMLBaseElement -> Nullable JSString -> IO ()
@@ -37,6 +53,15 @@
         (MonadIO m, FromJSString result) =>
           HTMLBaseElement -> m (Maybe result)
 getHref self = liftIO (fromMaybeJSString <$> (js_getHref (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLBaseElement.href Mozilla HTMLBaseElement.href documentation> 
+getHrefUnsafe ::
+              (MonadIO m, HasCallStack, FromJSString result) =>
+                HTMLBaseElement -> m result
+getHrefUnsafe self
+  = liftIO
+      ((fromMaybeJSString <$> (js_getHref (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLBaseElement.href Mozilla HTMLBaseElement.href documentation> 
 getHrefUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/HTMLBaseFontElement.hs b/src/GHCJS/DOM/JSFFI/Generated/HTMLBaseFontElement.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/HTMLBaseFontElement.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/HTMLBaseFontElement.hs
@@ -1,11 +1,16 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.HTMLBaseFontElement
        (js_setColor, setColor, js_getColor, getColor, js_setFace, setFace,
         js_getFace, getFace, js_setSize, setSize, js_getSize, getSize,
-        HTMLBaseFontElement, castToHTMLBaseFontElement,
-        gTypeHTMLBaseFontElement)
+        HTMLBaseFontElement(..), gTypeHTMLBaseFontElement)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -21,6 +26,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"color\"] = $2;" js_setColor
         :: HTMLBaseFontElement -> JSString -> IO ()
diff --git a/src/GHCJS/DOM/JSFFI/Generated/HTMLBodyElement.hs b/src/GHCJS/DOM/JSFFI/Generated/HTMLBodyElement.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/HTMLBodyElement.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/HTMLBodyElement.hs
@@ -1,4 +1,9 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.HTMLBodyElement
        (js_setALink, setALink, js_getALink, getALink, js_setBackground,
         setBackground, js_getBackground, getBackground, js_setBgColor,
@@ -7,9 +12,10 @@
         js_setVLink, setVLink, js_getVLink, getVLink, beforeUnload,
         hashChange, message, offline, online, popState, resize, storage,
         unload, orientationChange, blur, error, focus, load,
-        HTMLBodyElement, castToHTMLBodyElement, gTypeHTMLBodyElement)
+        HTMLBodyElement(..), gTypeHTMLBodyElement)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -25,6 +31,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"aLink\"] = $2;" js_setALink
         :: HTMLBodyElement -> JSString -> IO ()
diff --git a/src/GHCJS/DOM/JSFFI/Generated/HTMLButtonElement.hs b/src/GHCJS/DOM/JSFFI/Generated/HTMLButtonElement.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/HTMLButtonElement.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/HTMLButtonElement.hs
@@ -1,24 +1,32 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.HTMLButtonElement
        (js_checkValidity, checkValidity, checkValidity_,
         js_setCustomValidity, setCustomValidity, js_setAutofocus,
         setAutofocus, js_getAutofocus, getAutofocus, js_setDisabled,
         setDisabled, js_getDisabled, getDisabled, js_getForm, getForm,
-        getFormUnchecked, js_setFormAction, setFormAction,
+        getFormUnsafe, getFormUnchecked, js_setFormAction, setFormAction,
         js_getFormAction, getFormAction, js_setFormEnctype, setFormEnctype,
-        js_getFormEnctype, getFormEnctype, getFormEnctypeUnchecked,
-        js_setFormMethod, setFormMethod, js_getFormMethod, getFormMethod,
+        js_getFormEnctype, getFormEnctype, getFormEnctypeUnsafe,
+        getFormEnctypeUnchecked, js_setFormMethod, setFormMethod,
+        js_getFormMethod, getFormMethod, getFormMethodUnsafe,
         getFormMethodUnchecked, js_setFormNoValidate, setFormNoValidate,
         js_getFormNoValidate, getFormNoValidate, js_setFormTarget,
         setFormTarget, js_getFormTarget, getFormTarget, js_setName,
         setName, js_getName, getName, js_setType, setType, js_getType,
-        getType, getTypeUnchecked, js_setValue, setValue, js_getValue,
-        getValue, js_getWillValidate, getWillValidate, js_getValidity,
-        getValidity, getValidityUnchecked, js_getValidationMessage,
-        getValidationMessage, js_getLabels, getLabels, getLabelsUnchecked,
-        HTMLButtonElement, castToHTMLButtonElement, gTypeHTMLButtonElement)
+        getType, getTypeUnsafe, getTypeUnchecked, js_setValue, setValue,
+        js_getValue, getValue, js_getWillValidate, getWillValidate,
+        js_getValidity, getValidity, getValidityUnsafe,
+        getValidityUnchecked, js_getValidationMessage,
+        getValidationMessage, js_getLabels, getLabels, getLabelsUnsafe,
+        getLabelsUnchecked, HTMLButtonElement(..), gTypeHTMLButtonElement)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -34,6 +42,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe
         "($1[\"checkValidity\"]() ? 1 : 0)" js_checkValidity ::
@@ -95,6 +113,14 @@
 getForm self = liftIO (nullableToMaybe <$> (js_getForm (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLButtonElement.form Mozilla HTMLButtonElement.form documentation> 
+getFormUnsafe ::
+              (MonadIO m, HasCallStack) => HTMLButtonElement -> m HTMLFormElement
+getFormUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getForm (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLButtonElement.form Mozilla HTMLButtonElement.form documentation> 
 getFormUnchecked ::
                  (MonadIO m) => HTMLButtonElement -> m HTMLFormElement
 getFormUnchecked self
@@ -140,6 +166,15 @@
   = liftIO (fromMaybeJSString <$> (js_getFormEnctype (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLButtonElement.formEnctype Mozilla HTMLButtonElement.formEnctype documentation> 
+getFormEnctypeUnsafe ::
+                     (MonadIO m, HasCallStack, FromJSString result) =>
+                       HTMLButtonElement -> m result
+getFormEnctypeUnsafe self
+  = liftIO
+      ((fromMaybeJSString <$> (js_getFormEnctype (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLButtonElement.formEnctype Mozilla HTMLButtonElement.formEnctype documentation> 
 getFormEnctypeUnchecked ::
                         (MonadIO m, FromJSString result) => HTMLButtonElement -> m result
 getFormEnctypeUnchecked self
@@ -167,6 +202,15 @@
   = liftIO (fromMaybeJSString <$> (js_getFormMethod (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLButtonElement.formMethod Mozilla HTMLButtonElement.formMethod documentation> 
+getFormMethodUnsafe ::
+                    (MonadIO m, HasCallStack, FromJSString result) =>
+                      HTMLButtonElement -> m result
+getFormMethodUnsafe self
+  = liftIO
+      ((fromMaybeJSString <$> (js_getFormMethod (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLButtonElement.formMethod Mozilla HTMLButtonElement.formMethod documentation> 
 getFormMethodUnchecked ::
                        (MonadIO m, FromJSString result) => HTMLButtonElement -> m result
 getFormMethodUnchecked self
@@ -242,6 +286,15 @@
 getType self = liftIO (fromMaybeJSString <$> (js_getType (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLButtonElement.type Mozilla HTMLButtonElement.type documentation> 
+getTypeUnsafe ::
+              (MonadIO m, HasCallStack, FromJSString result) =>
+                HTMLButtonElement -> m result
+getTypeUnsafe self
+  = liftIO
+      ((fromMaybeJSString <$> (js_getType (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLButtonElement.type Mozilla HTMLButtonElement.type documentation> 
 getTypeUnchecked ::
                  (MonadIO m, FromJSString result) => HTMLButtonElement -> m result
 getTypeUnchecked self
@@ -280,6 +333,14 @@
   = liftIO (nullableToMaybe <$> (js_getValidity (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLButtonElement.validity Mozilla HTMLButtonElement.validity documentation> 
+getValidityUnsafe ::
+                  (MonadIO m, HasCallStack) => HTMLButtonElement -> m ValidityState
+getValidityUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getValidity (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLButtonElement.validity Mozilla HTMLButtonElement.validity documentation> 
 getValidityUnchecked ::
                      (MonadIO m) => HTMLButtonElement -> m ValidityState
 getValidityUnchecked self
@@ -300,6 +361,14 @@
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLButtonElement.labels Mozilla HTMLButtonElement.labels documentation> 
 getLabels :: (MonadIO m) => HTMLButtonElement -> m (Maybe NodeList)
 getLabels self = liftIO (nullableToMaybe <$> (js_getLabels (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLButtonElement.labels Mozilla HTMLButtonElement.labels documentation> 
+getLabelsUnsafe ::
+                (MonadIO m, HasCallStack) => HTMLButtonElement -> m NodeList
+getLabelsUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getLabels (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLButtonElement.labels Mozilla HTMLButtonElement.labels documentation> 
 getLabelsUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/HTMLCanvasElement.hs b/src/GHCJS/DOM/JSFFI/Generated/HTMLCanvasElement.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/HTMLCanvasElement.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/HTMLCanvasElement.hs
@@ -1,12 +1,18 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.HTMLCanvasElement
        (js_toDataURL, toDataURL, toDataURL_, js_getContext, getContext,
         getContext_, js_probablySupportsContext, probablySupportsContext,
         probablySupportsContext_, js_setWidth, setWidth, js_getWidth,
         getWidth, js_setHeight, setHeight, js_getHeight, getHeight,
-        HTMLCanvasElement, castToHTMLCanvasElement, gTypeHTMLCanvasElement)
+        HTMLCanvasElement(..), gTypeHTMLCanvasElement)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -22,6 +28,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"toDataURL\"]($2)"
         js_toDataURL ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/HTMLCollection.hs b/src/GHCJS/DOM/JSFFI/Generated/HTMLCollection.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/HTMLCollection.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/HTMLCollection.hs
@@ -1,11 +1,17 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.HTMLCollection
-       (js_item, item, item_, itemUnchecked, js_namedItem, namedItem,
-        namedItem_, namedItemUnchecked, js_getLength, getLength,
-        HTMLCollection, castToHTMLCollection, gTypeHTMLCollection,
+       (js_item, item, item_, itemUnsafe, itemUnchecked, js_namedItem,
+        namedItem, namedItem_, namedItemUnsafe, namedItemUnchecked,
+        js_getLength, getLength, HTMLCollection(..), gTypeHTMLCollection,
         IsHTMLCollection, toHTMLCollection)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -21,6 +27,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"item\"]($2)" js_item ::
         HTMLCollection -> Word -> IO (Nullable Node)
@@ -39,6 +55,15 @@
   = liftIO (void (js_item (toHTMLCollection self) index))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLCollection.item Mozilla HTMLCollection.item documentation> 
+itemUnsafe ::
+           (MonadIO m, IsHTMLCollection self, HasCallStack) =>
+             self -> Word -> m Node
+itemUnsafe self index
+  = liftIO
+      ((nullableToMaybe <$> (js_item (toHTMLCollection self) index)) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLCollection.item Mozilla HTMLCollection.item documentation> 
 itemUnchecked ::
               (MonadIO m, IsHTMLCollection self) => self -> Word -> m Node
 itemUnchecked self index
@@ -65,6 +90,17 @@
 namedItem_ self name
   = liftIO
       (void (js_namedItem (toHTMLCollection self) (toJSString name)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLCollection.namedItem Mozilla HTMLCollection.namedItem documentation> 
+namedItemUnsafe ::
+                (MonadIO m, IsHTMLCollection self, ToJSString name,
+                 HasCallStack) =>
+                  self -> name -> m Node
+namedItemUnsafe self name
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_namedItem (toHTMLCollection self) (toJSString name)))
+         >>= maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLCollection.namedItem Mozilla HTMLCollection.namedItem documentation> 
 namedItemUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/HTMLDListElement.hs b/src/GHCJS/DOM/JSFFI/Generated/HTMLDListElement.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/HTMLDListElement.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/HTMLDListElement.hs
@@ -1,9 +1,15 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.HTMLDListElement
        (js_setCompact, setCompact, js_getCompact, getCompact,
-        HTMLDListElement, castToHTMLDListElement, gTypeHTMLDListElement)
+        HTMLDListElement(..), gTypeHTMLDListElement)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -19,6 +25,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"compact\"] = $2;"
         js_setCompact :: HTMLDListElement -> Bool -> IO ()
diff --git a/src/GHCJS/DOM/JSFFI/Generated/HTMLDataListElement.hs b/src/GHCJS/DOM/JSFFI/Generated/HTMLDataListElement.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/HTMLDataListElement.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/HTMLDataListElement.hs
@@ -1,10 +1,15 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.HTMLDataListElement
-       (js_getOptions, getOptions, getOptionsUnchecked,
-        HTMLDataListElement, castToHTMLDataListElement,
-        gTypeHTMLDataListElement)
+       (js_getOptions, getOptions, getOptionsUnsafe, getOptionsUnchecked,
+        HTMLDataListElement(..), gTypeHTMLDataListElement)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -20,6 +25,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"options\"]" js_getOptions ::
         HTMLDataListElement -> IO (Nullable HTMLCollection)
@@ -29,6 +44,15 @@
            (MonadIO m) => HTMLDataListElement -> m (Maybe HTMLCollection)
 getOptions self
   = liftIO (nullableToMaybe <$> (js_getOptions (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLDataListElement.options Mozilla HTMLDataListElement.options documentation> 
+getOptionsUnsafe ::
+                 (MonadIO m, HasCallStack) =>
+                   HTMLDataListElement -> m HTMLCollection
+getOptionsUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getOptions (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLDataListElement.options Mozilla HTMLDataListElement.options documentation> 
 getOptionsUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/HTMLDetailsElement.hs b/src/GHCJS/DOM/JSFFI/Generated/HTMLDetailsElement.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/HTMLDetailsElement.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/HTMLDetailsElement.hs
@@ -1,9 +1,15 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.HTMLDetailsElement
-       (js_setOpen, setOpen, js_getOpen, getOpen, HTMLDetailsElement,
-        castToHTMLDetailsElement, gTypeHTMLDetailsElement)
+       (js_setOpen, setOpen, js_getOpen, getOpen, HTMLDetailsElement(..),
+        gTypeHTMLDetailsElement)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -19,6 +25,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"open\"] = $2;" js_setOpen ::
         HTMLDetailsElement -> Bool -> IO ()
diff --git a/src/GHCJS/DOM/JSFFI/Generated/HTMLDirectoryElement.hs b/src/GHCJS/DOM/JSFFI/Generated/HTMLDirectoryElement.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/HTMLDirectoryElement.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/HTMLDirectoryElement.hs
@@ -1,10 +1,15 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.HTMLDirectoryElement
        (js_setCompact, setCompact, js_getCompact, getCompact,
-        HTMLDirectoryElement, castToHTMLDirectoryElement,
-        gTypeHTMLDirectoryElement)
+        HTMLDirectoryElement(..), gTypeHTMLDirectoryElement)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -20,6 +25,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"compact\"] = $2;"
         js_setCompact :: HTMLDirectoryElement -> Bool -> IO ()
diff --git a/src/GHCJS/DOM/JSFFI/Generated/HTMLDivElement.hs b/src/GHCJS/DOM/JSFFI/Generated/HTMLDivElement.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/HTMLDivElement.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/HTMLDivElement.hs
@@ -1,9 +1,15 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.HTMLDivElement
-       (js_setAlign, setAlign, js_getAlign, getAlign, HTMLDivElement,
-        castToHTMLDivElement, gTypeHTMLDivElement)
+       (js_setAlign, setAlign, js_getAlign, getAlign, HTMLDivElement(..),
+        gTypeHTMLDivElement)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -19,6 +25,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"align\"] = $2;" js_setAlign
         :: HTMLDivElement -> JSString -> IO ()
diff --git a/src/GHCJS/DOM/JSFFI/Generated/HTMLDocument.hs b/src/GHCJS/DOM/JSFFI/Generated/HTMLDocument.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/HTMLDocument.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/HTMLDocument.hs
@@ -1,24 +1,33 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.HTMLDocument
        (js_open, open, js_close, close, js_write, write, js_writeln,
         writeln, js_clear, clear, js_captureEvents, captureEvents,
         js_releaseEvents, releaseEvents, js_getEmbeds, getEmbeds,
-        getEmbedsUnchecked, js_getPlugins, getPlugins, getPluginsUnchecked,
-        js_getScripts, getScripts, getScriptsUnchecked, js_getAll, getAll,
-        getAllUnchecked, js_getWidth, getWidth, js_getHeight, getHeight,
-        js_setDir, setDir, js_getDir, getDir, getDirUnchecked,
-        js_setDesignMode, setDesignMode, js_getDesignMode, getDesignMode,
-        getDesignModeUnchecked, js_getCompatMode, getCompatMode,
-        js_setBgColor, setBgColor, js_getBgColor, getBgColor,
-        getBgColorUnchecked, js_setFgColor, setFgColor, js_getFgColor,
-        getFgColor, getFgColorUnchecked, js_setAlinkColor, setAlinkColor,
-        js_getAlinkColor, getAlinkColor, getAlinkColorUnchecked,
-        js_setLinkColor, setLinkColor, js_getLinkColor, getLinkColor,
+        getEmbedsUnsafe, getEmbedsUnchecked, js_getPlugins, getPlugins,
+        getPluginsUnsafe, getPluginsUnchecked, js_getScripts, getScripts,
+        getScriptsUnsafe, getScriptsUnchecked, js_getAll, getAll,
+        getAllUnsafe, getAllUnchecked, js_getWidth, getWidth, js_getHeight,
+        getHeight, js_setDir, setDir, js_getDir, getDir, getDirUnsafe,
+        getDirUnchecked, js_setDesignMode, setDesignMode, js_getDesignMode,
+        getDesignMode, getDesignModeUnsafe, getDesignModeUnchecked,
+        js_getCompatMode, getCompatMode, js_setBgColor, setBgColor,
+        js_getBgColor, getBgColor, getBgColorUnsafe, getBgColorUnchecked,
+        js_setFgColor, setFgColor, js_getFgColor, getFgColor,
+        getFgColorUnsafe, getFgColorUnchecked, js_setAlinkColor,
+        setAlinkColor, js_getAlinkColor, getAlinkColor,
+        getAlinkColorUnsafe, getAlinkColorUnchecked, js_setLinkColor,
+        setLinkColor, js_getLinkColor, getLinkColor, getLinkColorUnsafe,
         getLinkColorUnchecked, js_setVlinkColor, setVlinkColor,
-        js_getVlinkColor, getVlinkColor, getVlinkColorUnchecked,
-        HTMLDocument, castToHTMLDocument, gTypeHTMLDocument)
+        js_getVlinkColor, getVlinkColor, getVlinkColorUnsafe,
+        getVlinkColorUnchecked, HTMLDocument(..), gTypeHTMLDocument)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -34,6 +43,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"open\"]()" js_open ::
         HTMLDocument -> IO ()
@@ -95,6 +114,14 @@
 getEmbeds self = liftIO (nullableToMaybe <$> (js_getEmbeds (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLDocument.embeds Mozilla HTMLDocument.embeds documentation> 
+getEmbedsUnsafe ::
+                (MonadIO m, HasCallStack) => HTMLDocument -> m HTMLCollection
+getEmbedsUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getEmbeds (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLDocument.embeds Mozilla HTMLDocument.embeds documentation> 
 getEmbedsUnchecked ::
                    (MonadIO m) => HTMLDocument -> m HTMLCollection
 getEmbedsUnchecked self
@@ -110,6 +137,14 @@
   = liftIO (nullableToMaybe <$> (js_getPlugins (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLDocument.plugins Mozilla HTMLDocument.plugins documentation> 
+getPluginsUnsafe ::
+                 (MonadIO m, HasCallStack) => HTMLDocument -> m HTMLCollection
+getPluginsUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getPlugins (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLDocument.plugins Mozilla HTMLDocument.plugins documentation> 
 getPluginsUnchecked ::
                     (MonadIO m) => HTMLDocument -> m HTMLCollection
 getPluginsUnchecked self
@@ -125,6 +160,14 @@
   = liftIO (nullableToMaybe <$> (js_getScripts (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLDocument.scripts Mozilla HTMLDocument.scripts documentation> 
+getScriptsUnsafe ::
+                 (MonadIO m, HasCallStack) => HTMLDocument -> m HTMLCollection
+getScriptsUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getScripts (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLDocument.scripts Mozilla HTMLDocument.scripts documentation> 
 getScriptsUnchecked ::
                     (MonadIO m) => HTMLDocument -> m HTMLCollection
 getScriptsUnchecked self
@@ -139,6 +182,14 @@
 getAll self = liftIO (nullableToMaybe <$> (js_getAll (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLDocument.all Mozilla HTMLDocument.all documentation> 
+getAllUnsafe ::
+             (MonadIO m, HasCallStack) => HTMLDocument -> m HTMLAllCollection
+getAllUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getAll (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLDocument.all Mozilla HTMLDocument.all documentation> 
 getAllUnchecked ::
                 (MonadIO m) => HTMLDocument -> m HTMLAllCollection
 getAllUnchecked self
@@ -176,6 +227,15 @@
 getDir self = liftIO (fromMaybeJSString <$> (js_getDir (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLDocument.dir Mozilla HTMLDocument.dir documentation> 
+getDirUnsafe ::
+             (MonadIO m, HasCallStack, FromJSString result) =>
+               HTMLDocument -> m result
+getDirUnsafe self
+  = liftIO
+      ((fromMaybeJSString <$> (js_getDir (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLDocument.dir Mozilla HTMLDocument.dir documentation> 
 getDirUnchecked ::
                 (MonadIO m, FromJSString result) => HTMLDocument -> m result
 getDirUnchecked self
@@ -201,6 +261,15 @@
   = liftIO (fromMaybeJSString <$> (js_getDesignMode (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLDocument.designMode Mozilla HTMLDocument.designMode documentation> 
+getDesignModeUnsafe ::
+                    (MonadIO m, HasCallStack, FromJSString result) =>
+                      HTMLDocument -> m result
+getDesignModeUnsafe self
+  = liftIO
+      ((fromMaybeJSString <$> (js_getDesignMode (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLDocument.designMode Mozilla HTMLDocument.designMode documentation> 
 getDesignModeUnchecked ::
                        (MonadIO m, FromJSString result) => HTMLDocument -> m result
 getDesignModeUnchecked self
@@ -236,6 +305,15 @@
   = liftIO (fromMaybeJSString <$> (js_getBgColor (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLDocument.bgColor Mozilla HTMLDocument.bgColor documentation> 
+getBgColorUnsafe ::
+                 (MonadIO m, HasCallStack, FromJSString result) =>
+                   HTMLDocument -> m result
+getBgColorUnsafe self
+  = liftIO
+      ((fromMaybeJSString <$> (js_getBgColor (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLDocument.bgColor Mozilla HTMLDocument.bgColor documentation> 
 getBgColorUnchecked ::
                     (MonadIO m, FromJSString result) => HTMLDocument -> m result
 getBgColorUnchecked self
@@ -261,6 +339,15 @@
   = liftIO (fromMaybeJSString <$> (js_getFgColor (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLDocument.fgColor Mozilla HTMLDocument.fgColor documentation> 
+getFgColorUnsafe ::
+                 (MonadIO m, HasCallStack, FromJSString result) =>
+                   HTMLDocument -> m result
+getFgColorUnsafe self
+  = liftIO
+      ((fromMaybeJSString <$> (js_getFgColor (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLDocument.fgColor Mozilla HTMLDocument.fgColor documentation> 
 getFgColorUnchecked ::
                     (MonadIO m, FromJSString result) => HTMLDocument -> m result
 getFgColorUnchecked self
@@ -286,6 +373,15 @@
   = liftIO (fromMaybeJSString <$> (js_getAlinkColor (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLDocument.alinkColor Mozilla HTMLDocument.alinkColor documentation> 
+getAlinkColorUnsafe ::
+                    (MonadIO m, HasCallStack, FromJSString result) =>
+                      HTMLDocument -> m result
+getAlinkColorUnsafe self
+  = liftIO
+      ((fromMaybeJSString <$> (js_getAlinkColor (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLDocument.alinkColor Mozilla HTMLDocument.alinkColor documentation> 
 getAlinkColorUnchecked ::
                        (MonadIO m, FromJSString result) => HTMLDocument -> m result
 getAlinkColorUnchecked self
@@ -312,6 +408,15 @@
   = liftIO (fromMaybeJSString <$> (js_getLinkColor (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLDocument.linkColor Mozilla HTMLDocument.linkColor documentation> 
+getLinkColorUnsafe ::
+                   (MonadIO m, HasCallStack, FromJSString result) =>
+                     HTMLDocument -> m result
+getLinkColorUnsafe self
+  = liftIO
+      ((fromMaybeJSString <$> (js_getLinkColor (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLDocument.linkColor Mozilla HTMLDocument.linkColor documentation> 
 getLinkColorUnchecked ::
                       (MonadIO m, FromJSString result) => HTMLDocument -> m result
 getLinkColorUnchecked self
@@ -336,6 +441,15 @@
                 HTMLDocument -> m (Maybe result)
 getVlinkColor self
   = liftIO (fromMaybeJSString <$> (js_getVlinkColor (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLDocument.vlinkColor Mozilla HTMLDocument.vlinkColor documentation> 
+getVlinkColorUnsafe ::
+                    (MonadIO m, HasCallStack, FromJSString result) =>
+                      HTMLDocument -> m result
+getVlinkColorUnsafe self
+  = liftIO
+      ((fromMaybeJSString <$> (js_getVlinkColor (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLDocument.vlinkColor Mozilla HTMLDocument.vlinkColor documentation> 
 getVlinkColorUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/HTMLElement.hs b/src/GHCJS/DOM/JSFFI/Generated/HTMLElement.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/HTMLElement.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/HTMLElement.hs
@@ -1,28 +1,36 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.HTMLElement
        (js_insertAdjacentElement, insertAdjacentElement,
-        insertAdjacentElement_, insertAdjacentElementUnchecked,
-        js_insertAdjacentHTML, insertAdjacentHTML, js_insertAdjacentText,
-        insertAdjacentText, js_click, click, js_setTitle, setTitle,
-        js_getTitle, getTitle, js_setLang, setLang, js_getLang, getLang,
-        js_setTranslate, setTranslate, js_getTranslate, getTranslate,
-        js_setDir, setDir, js_getDir, getDir, js_setTabIndex, setTabIndex,
-        js_getTabIndex, getTabIndex, js_setDraggable, setDraggable,
-        js_getDraggable, getDraggable, js_setWebkitdropzone,
-        setWebkitdropzone, js_getWebkitdropzone, getWebkitdropzone,
-        js_setHidden, setHidden, js_getHidden, getHidden, js_setAccessKey,
-        setAccessKey, js_getAccessKey, getAccessKey, js_setInnerText,
-        setInnerText, js_getInnerText, getInnerText, getInnerTextUnchecked,
-        js_setOuterText, setOuterText, js_getOuterText, getOuterText,
+        insertAdjacentElement_, insertAdjacentElementUnsafe,
+        insertAdjacentElementUnchecked, js_insertAdjacentHTML,
+        insertAdjacentHTML, js_insertAdjacentText, insertAdjacentText,
+        js_click, click, js_setTitle, setTitle, js_getTitle, getTitle,
+        js_setLang, setLang, js_getLang, getLang, js_setTranslate,
+        setTranslate, js_getTranslate, getTranslate, js_setDir, setDir,
+        js_getDir, getDir, js_setTabIndex, setTabIndex, js_getTabIndex,
+        getTabIndex, js_setDraggable, setDraggable, js_getDraggable,
+        getDraggable, js_setWebkitdropzone, setWebkitdropzone,
+        js_getWebkitdropzone, getWebkitdropzone, js_setHidden, setHidden,
+        js_getHidden, getHidden, js_setAccessKey, setAccessKey,
+        js_getAccessKey, getAccessKey, js_setInnerText, setInnerText,
+        js_getInnerText, getInnerText, getInnerTextUnsafe,
+        getInnerTextUnchecked, js_setOuterText, setOuterText,
+        js_getOuterText, getOuterText, getOuterTextUnsafe,
         getOuterTextUnchecked, js_getChildren, getChildren,
-        getChildrenUnchecked, js_setContentEditable, setContentEditable,
-        js_getContentEditable, getContentEditable,
-        getContentEditableUnchecked, js_getIsContentEditable,
-        getIsContentEditable, js_setSpellcheck, setSpellcheck,
-        js_getSpellcheck, getSpellcheck, HTMLElement, castToHTMLElement,
+        getChildrenUnsafe, getChildrenUnchecked, js_setContentEditable,
+        setContentEditable, js_getContentEditable, getContentEditable,
+        getContentEditableUnsafe, getContentEditableUnchecked,
+        js_getIsContentEditable, getIsContentEditable, js_setSpellcheck,
+        setSpellcheck, js_getSpellcheck, getSpellcheck, HTMLElement(..),
         gTypeHTMLElement, IsHTMLElement, toHTMLElement)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -38,6 +46,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe
         "$1[\"insertAdjacentElement\"]($2,\n$3)" js_insertAdjacentElement
@@ -68,6 +86,18 @@
             (maybeToNullable (fmap toElement element))))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement.insertAdjacentElement Mozilla HTMLElement.insertAdjacentElement documentation> 
+insertAdjacentElementUnsafe ::
+                            (MonadIO m, IsHTMLElement self, ToJSString where',
+                             IsElement element, HasCallStack) =>
+                              self -> where' -> Maybe element -> m Element
+insertAdjacentElementUnsafe self where' element
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_insertAdjacentElement (toHTMLElement self) (toJSString where')
+             (maybeToNullable (fmap toElement element))))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement.insertAdjacentElement Mozilla HTMLElement.insertAdjacentElement documentation> 
 insertAdjacentElementUnchecked ::
                                (MonadIO m, IsHTMLElement self, ToJSString where',
                                 IsElement element) =>
@@ -301,6 +331,16 @@
       (fromMaybeJSString <$> (js_getInnerText (toHTMLElement self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement.innerText Mozilla HTMLElement.innerText documentation> 
+getInnerTextUnsafe ::
+                   (MonadIO m, IsHTMLElement self, HasCallStack,
+                    FromJSString result) =>
+                     self -> m result
+getInnerTextUnsafe self
+  = liftIO
+      ((fromMaybeJSString <$> (js_getInnerText (toHTMLElement self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement.innerText Mozilla HTMLElement.innerText documentation> 
 getInnerTextUnchecked ::
                       (MonadIO m, IsHTMLElement self, FromJSString result) =>
                         self -> m result
@@ -332,6 +372,16 @@
       (fromMaybeJSString <$> (js_getOuterText (toHTMLElement self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement.outerText Mozilla HTMLElement.outerText documentation> 
+getOuterTextUnsafe ::
+                   (MonadIO m, IsHTMLElement self, HasCallStack,
+                    FromJSString result) =>
+                     self -> m result
+getOuterTextUnsafe self
+  = liftIO
+      ((fromMaybeJSString <$> (js_getOuterText (toHTMLElement self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement.outerText Mozilla HTMLElement.outerText documentation> 
 getOuterTextUnchecked ::
                       (MonadIO m, IsHTMLElement self, FromJSString result) =>
                         self -> m result
@@ -351,6 +401,15 @@
       (nullableToMaybe <$> (js_getChildren (toHTMLElement self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement.children Mozilla HTMLElement.children documentation> 
+getChildrenUnsafe ::
+                  (MonadIO m, IsHTMLElement self, HasCallStack) =>
+                    self -> m HTMLCollection
+getChildrenUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getChildren (toHTMLElement self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement.children Mozilla HTMLElement.children documentation> 
 getChildrenUnchecked ::
                      (MonadIO m, IsHTMLElement self) => self -> m HTMLCollection
 getChildrenUnchecked self
@@ -380,6 +439,17 @@
   = liftIO
       (fromMaybeJSString <$>
          (js_getContentEditable (toHTMLElement self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement.contentEditable Mozilla HTMLElement.contentEditable documentation> 
+getContentEditableUnsafe ::
+                         (MonadIO m, IsHTMLElement self, HasCallStack,
+                          FromJSString result) =>
+                           self -> m result
+getContentEditableUnsafe self
+  = liftIO
+      ((fromMaybeJSString <$>
+          (js_getContentEditable (toHTMLElement self)))
+         >>= maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement.contentEditable Mozilla HTMLElement.contentEditable documentation> 
 getContentEditableUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/HTMLEmbedElement.hs b/src/GHCJS/DOM/JSFFI/Generated/HTMLEmbedElement.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/HTMLEmbedElement.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/HTMLEmbedElement.hs
@@ -1,14 +1,20 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.HTMLEmbedElement
        (js_getSVGDocument, getSVGDocument, getSVGDocument_,
-        getSVGDocumentUnchecked, js_setAlign, setAlign, js_getAlign,
-        getAlign, js_setHeight, setHeight, js_getHeight, getHeight,
-        js_setName, setName, js_getName, getName, js_setSrc, setSrc,
-        js_getSrc, getSrc, js_setType, setType, js_getType, getType,
-        js_setWidth, setWidth, js_getWidth, getWidth, HTMLEmbedElement,
-        castToHTMLEmbedElement, gTypeHTMLEmbedElement)
+        getSVGDocumentUnsafe, getSVGDocumentUnchecked, js_setAlign,
+        setAlign, js_getAlign, getAlign, js_setHeight, setHeight,
+        js_getHeight, getHeight, js_setName, setName, js_getName, getName,
+        js_setSrc, setSrc, js_getSrc, getSrc, js_setType, setType,
+        js_getType, getType, js_setWidth, setWidth, js_getWidth, getWidth,
+        HTMLEmbedElement(..), gTypeHTMLEmbedElement)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -24,6 +30,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"getSVGDocument\"]()"
         js_getSVGDocument :: HTMLEmbedElement -> IO (Nullable SVGDocument)
@@ -37,6 +53,14 @@
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLEmbedElement.getSVGDocument Mozilla HTMLEmbedElement.getSVGDocument documentation> 
 getSVGDocument_ :: (MonadIO m) => HTMLEmbedElement -> m ()
 getSVGDocument_ self = liftIO (void (js_getSVGDocument (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLEmbedElement.getSVGDocument Mozilla HTMLEmbedElement.getSVGDocument documentation> 
+getSVGDocumentUnsafe ::
+                     (MonadIO m, HasCallStack) => HTMLEmbedElement -> m SVGDocument
+getSVGDocumentUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getSVGDocument (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLEmbedElement.getSVGDocument Mozilla HTMLEmbedElement.getSVGDocument documentation> 
 getSVGDocumentUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/HTMLFieldSetElement.hs b/src/GHCJS/DOM/JSFFI/Generated/HTMLFieldSetElement.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/HTMLFieldSetElement.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/HTMLFieldSetElement.hs
@@ -1,16 +1,23 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.HTMLFieldSetElement
        (js_checkValidity, checkValidity, checkValidity_,
         js_setCustomValidity, setCustomValidity, js_setDisabled,
         setDisabled, js_getDisabled, getDisabled, js_getForm, getForm,
-        getFormUnchecked, js_setName, setName, js_getName, getName,
-        js_getType, getType, js_getElements, getElements,
-        getElementsUnchecked, js_getWillValidate, getWillValidate,
-        js_getValidity, getValidity, getValidityUnchecked,
-        js_getValidationMessage, getValidationMessage, HTMLFieldSetElement,
-        castToHTMLFieldSetElement, gTypeHTMLFieldSetElement)
+        getFormUnsafe, getFormUnchecked, js_setName, setName, js_getName,
+        getName, js_getType, getType, js_getElements, getElements,
+        getElementsUnsafe, getElementsUnchecked, js_getWillValidate,
+        getWillValidate, js_getValidity, getValidity, getValidityUnsafe,
+        getValidityUnchecked, js_getValidationMessage,
+        getValidationMessage, HTMLFieldSetElement(..),
+        gTypeHTMLFieldSetElement)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -26,6 +33,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe
         "($1[\"checkValidity\"]() ? 1 : 0)" js_checkValidity ::
@@ -73,6 +90,15 @@
 getForm self = liftIO (nullableToMaybe <$> (js_getForm (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLFieldSetElement.form Mozilla HTMLFieldSetElement.form documentation> 
+getFormUnsafe ::
+              (MonadIO m, HasCallStack) =>
+                HTMLFieldSetElement -> m HTMLFormElement
+getFormUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getForm (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLFieldSetElement.form Mozilla HTMLFieldSetElement.form documentation> 
 getFormUnchecked ::
                  (MonadIO m) => HTMLFieldSetElement -> m HTMLFormElement
 getFormUnchecked self
@@ -112,6 +138,15 @@
   = liftIO (nullableToMaybe <$> (js_getElements (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLFieldSetElement.elements Mozilla HTMLFieldSetElement.elements documentation> 
+getElementsUnsafe ::
+                  (MonadIO m, HasCallStack) =>
+                    HTMLFieldSetElement -> m HTMLCollection
+getElementsUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getElements (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLFieldSetElement.elements Mozilla HTMLFieldSetElement.elements documentation> 
 getElementsUnchecked ::
                      (MonadIO m) => HTMLFieldSetElement -> m HTMLCollection
 getElementsUnchecked self
@@ -132,6 +167,14 @@
             (MonadIO m) => HTMLFieldSetElement -> m (Maybe ValidityState)
 getValidity self
   = liftIO (nullableToMaybe <$> (js_getValidity (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLFieldSetElement.validity Mozilla HTMLFieldSetElement.validity documentation> 
+getValidityUnsafe ::
+                  (MonadIO m, HasCallStack) => HTMLFieldSetElement -> m ValidityState
+getValidityUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getValidity (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLFieldSetElement.validity Mozilla HTMLFieldSetElement.validity documentation> 
 getValidityUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/HTMLFontElement.hs b/src/GHCJS/DOM/JSFFI/Generated/HTMLFontElement.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/HTMLFontElement.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/HTMLFontElement.hs
@@ -1,10 +1,16 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.HTMLFontElement
        (js_setColor, setColor, js_getColor, getColor, js_setFace, setFace,
         js_getFace, getFace, js_setSize, setSize, js_getSize, getSize,
-        HTMLFontElement, castToHTMLFontElement, gTypeHTMLFontElement)
+        HTMLFontElement(..), gTypeHTMLFontElement)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -20,6 +26,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"color\"] = $2;" js_setColor
         :: HTMLFontElement -> JSString -> IO ()
diff --git a/src/GHCJS/DOM/JSFFI/Generated/HTMLFormControlsCollection.hs b/src/GHCJS/DOM/JSFFI/Generated/HTMLFormControlsCollection.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/HTMLFormControlsCollection.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/HTMLFormControlsCollection.hs
@@ -1,10 +1,16 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.HTMLFormControlsCollection
-       (js__get, _get, _get_, _getUnchecked, js_namedItem, namedItem,
-        namedItem_, namedItemUnchecked, HTMLFormControlsCollection,
-        castToHTMLFormControlsCollection, gTypeHTMLFormControlsCollection)
+       (js__get, _get, _get_, _getUnsafe, _getUnchecked, js_namedItem,
+        namedItem, namedItem_, namedItemUnsafe, namedItemUnchecked,
+        HTMLFormControlsCollection(..), gTypeHTMLFormControlsCollection)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -20,6 +26,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"_get\"]($2)" js__get ::
         HTMLFormControlsCollection -> Word -> IO (Nullable Node)
@@ -35,6 +51,15 @@
 _get_ self index = liftIO (void (js__get (self) index))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLFormControlsCollection._get Mozilla HTMLFormControlsCollection._get documentation> 
+_getUnsafe ::
+           (MonadIO m, HasCallStack) =>
+             HTMLFormControlsCollection -> Word -> m Node
+_getUnsafe self index
+  = liftIO
+      ((nullableToMaybe <$> (js__get (self) index)) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLFormControlsCollection._get Mozilla HTMLFormControlsCollection._get documentation> 
 _getUnchecked ::
               (MonadIO m) => HTMLFormControlsCollection -> Word -> m Node
 _getUnchecked self index
@@ -58,6 +83,15 @@
              HTMLFormControlsCollection -> name -> m ()
 namedItem_ self name
   = liftIO (void (js_namedItem (self) (toJSString name)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLFormControlsCollection.namedItem Mozilla HTMLFormControlsCollection.namedItem documentation> 
+namedItemUnsafe ::
+                (MonadIO m, ToJSString name, HasCallStack) =>
+                  HTMLFormControlsCollection -> name -> m Node
+namedItemUnsafe self name
+  = liftIO
+      ((nullableToMaybe <$> (js_namedItem (self) (toJSString name))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLFormControlsCollection.namedItem Mozilla HTMLFormControlsCollection.namedItem documentation> 
 namedItemUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/HTMLFormElement.hs b/src/GHCJS/DOM/JSFFI/Generated/HTMLFormElement.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/HTMLFormElement.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/HTMLFormElement.hs
@@ -1,26 +1,33 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.HTMLFormElement
-       (js__get, _get, _get_, _getUnchecked, js_submit, submit, js_reset,
-        reset, js_checkValidity, checkValidity, checkValidity_,
-        js_requestAutocomplete, requestAutocomplete, js_setAcceptCharset,
-        setAcceptCharset, js_getAcceptCharset, getAcceptCharset,
-        js_setAction, setAction, js_getAction, getAction,
+       (js__get, _get, _get_, _getUnsafe, _getUnchecked, js_submit,
+        submit, js_reset, reset, js_checkValidity, checkValidity,
+        checkValidity_, js_requestAutocomplete, requestAutocomplete,
+        js_setAcceptCharset, setAcceptCharset, js_getAcceptCharset,
+        getAcceptCharset, js_setAction, setAction, js_getAction, getAction,
         js_setAutocomplete, setAutocomplete, js_getAutocomplete,
         getAutocomplete, js_setEnctype, setEnctype, js_getEnctype,
-        getEnctype, getEnctypeUnchecked, js_setEncoding, setEncoding,
-        js_getEncoding, getEncoding, getEncodingUnchecked, js_setMethod,
-        setMethod, js_getMethod, getMethod, getMethodUnchecked, js_setName,
+        getEnctype, getEnctypeUnsafe, getEnctypeUnchecked, js_setEncoding,
+        setEncoding, js_getEncoding, getEncoding, getEncodingUnsafe,
+        getEncodingUnchecked, js_setMethod, setMethod, js_getMethod,
+        getMethod, getMethodUnsafe, getMethodUnchecked, js_setName,
         setName, js_getName, getName, js_setNoValidate, setNoValidate,
         js_getNoValidate, getNoValidate, js_setTarget, setTarget,
         js_getTarget, getTarget, js_getElements, getElements,
-        getElementsUnchecked, js_getLength, getLength, js_setAutocorrect,
-        setAutocorrect, js_getAutocorrect, getAutocorrect,
-        js_setAutocapitalize, setAutocapitalize, js_getAutocapitalize,
-        getAutocapitalize, getAutocapitalizeUnchecked, autocomplete,
-        autocompleteerror, HTMLFormElement, castToHTMLFormElement,
-        gTypeHTMLFormElement)
+        getElementsUnsafe, getElementsUnchecked, js_getLength, getLength,
+        js_setAutocorrect, setAutocorrect, js_getAutocorrect,
+        getAutocorrect, js_setAutocapitalize, setAutocapitalize,
+        js_getAutocapitalize, getAutocapitalize, getAutocapitalizeUnsafe,
+        getAutocapitalizeUnchecked, autocomplete, autocompleteerror,
+        HTMLFormElement(..), gTypeHTMLFormElement)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -36,6 +43,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"_get\"]($2)" js__get ::
         HTMLFormElement -> Word -> IO (Nullable Element)
@@ -50,6 +67,14 @@
 _get_ self index = liftIO (void (js__get (self) index))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLFormElement._get Mozilla HTMLFormElement._get documentation> 
+_getUnsafe ::
+           (MonadIO m, HasCallStack) => HTMLFormElement -> Word -> m Element
+_getUnsafe self index
+  = liftIO
+      ((nullableToMaybe <$> (js__get (self) index)) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLFormElement._get Mozilla HTMLFormElement._get documentation> 
 _getUnchecked ::
               (MonadIO m) => HTMLFormElement -> Word -> m Element
 _getUnchecked self index
@@ -160,6 +185,15 @@
   = liftIO (fromMaybeJSString <$> (js_getEnctype (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLFormElement.enctype Mozilla HTMLFormElement.enctype documentation> 
+getEnctypeUnsafe ::
+                 (MonadIO m, HasCallStack, FromJSString result) =>
+                   HTMLFormElement -> m result
+getEnctypeUnsafe self
+  = liftIO
+      ((fromMaybeJSString <$> (js_getEnctype (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLFormElement.enctype Mozilla HTMLFormElement.enctype documentation> 
 getEnctypeUnchecked ::
                     (MonadIO m, FromJSString result) => HTMLFormElement -> m result
 getEnctypeUnchecked self
@@ -185,6 +219,15 @@
   = liftIO (fromMaybeJSString <$> (js_getEncoding (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLFormElement.encoding Mozilla HTMLFormElement.encoding documentation> 
+getEncodingUnsafe ::
+                  (MonadIO m, HasCallStack, FromJSString result) =>
+                    HTMLFormElement -> m result
+getEncodingUnsafe self
+  = liftIO
+      ((fromMaybeJSString <$> (js_getEncoding (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLFormElement.encoding Mozilla HTMLFormElement.encoding documentation> 
 getEncodingUnchecked ::
                      (MonadIO m, FromJSString result) => HTMLFormElement -> m result
 getEncodingUnchecked self
@@ -210,6 +253,15 @@
   = liftIO (fromMaybeJSString <$> (js_getMethod (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLFormElement.method Mozilla HTMLFormElement.method documentation> 
+getMethodUnsafe ::
+                (MonadIO m, HasCallStack, FromJSString result) =>
+                  HTMLFormElement -> m result
+getMethodUnsafe self
+  = liftIO
+      ((fromMaybeJSString <$> (js_getMethod (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLFormElement.method Mozilla HTMLFormElement.method documentation> 
 getMethodUnchecked ::
                    (MonadIO m, FromJSString result) => HTMLFormElement -> m result
 getMethodUnchecked self
@@ -271,6 +323,14 @@
   = liftIO (nullableToMaybe <$> (js_getElements (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLFormElement.elements Mozilla HTMLFormElement.elements documentation> 
+getElementsUnsafe ::
+                  (MonadIO m, HasCallStack) => HTMLFormElement -> m HTMLCollection
+getElementsUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getElements (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLFormElement.elements Mozilla HTMLFormElement.elements documentation> 
 getElementsUnchecked ::
                      (MonadIO m) => HTMLFormElement -> m HTMLCollection
 getElementsUnchecked self
@@ -316,6 +376,15 @@
                     HTMLFormElement -> m (Maybe result)
 getAutocapitalize self
   = liftIO (fromMaybeJSString <$> (js_getAutocapitalize (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLFormElement.autocapitalize Mozilla HTMLFormElement.autocapitalize documentation> 
+getAutocapitalizeUnsafe ::
+                        (MonadIO m, HasCallStack, FromJSString result) =>
+                          HTMLFormElement -> m result
+getAutocapitalizeUnsafe self
+  = liftIO
+      ((fromMaybeJSString <$> (js_getAutocapitalize (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLFormElement.autocapitalize Mozilla HTMLFormElement.autocapitalize documentation> 
 getAutocapitalizeUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/HTMLFrameElement.hs b/src/GHCJS/DOM/JSFFI/Generated/HTMLFrameElement.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/HTMLFrameElement.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/HTMLFrameElement.hs
@@ -1,22 +1,29 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.HTMLFrameElement
        (js_getSVGDocument, getSVGDocument, getSVGDocument_,
-        getSVGDocumentUnchecked, js_setFrameBorder, setFrameBorder,
-        js_getFrameBorder, getFrameBorder, js_setLongDesc, setLongDesc,
-        js_getLongDesc, getLongDesc, js_setMarginHeight, setMarginHeight,
-        js_getMarginHeight, getMarginHeight, js_setMarginWidth,
-        setMarginWidth, js_getMarginWidth, getMarginWidth, js_setName,
-        setName, js_getName, getName, js_setNoResize, setNoResize,
-        js_getNoResize, getNoResize, js_setScrolling, setScrolling,
-        js_getScrolling, getScrolling, js_setSrc, setSrc, js_getSrc,
-        getSrc, js_getContentDocument, getContentDocument,
+        getSVGDocumentUnsafe, getSVGDocumentUnchecked, js_setFrameBorder,
+        setFrameBorder, js_getFrameBorder, getFrameBorder, js_setLongDesc,
+        setLongDesc, js_getLongDesc, getLongDesc, js_setMarginHeight,
+        setMarginHeight, js_getMarginHeight, getMarginHeight,
+        js_setMarginWidth, setMarginWidth, js_getMarginWidth,
+        getMarginWidth, js_setName, setName, js_getName, getName,
+        js_setNoResize, setNoResize, js_getNoResize, getNoResize,
+        js_setScrolling, setScrolling, js_getScrolling, getScrolling,
+        js_setSrc, setSrc, js_getSrc, getSrc, js_getContentDocument,
+        getContentDocument, getContentDocumentUnsafe,
         getContentDocumentUnchecked, js_getContentWindow, getContentWindow,
-        getContentWindowUnchecked, js_setLocation, setLocation,
-        js_getLocation, getLocation, getLocationUnchecked, js_getWidth,
-        getWidth, js_getHeight, getHeight, HTMLFrameElement,
-        castToHTMLFrameElement, gTypeHTMLFrameElement)
+        getContentWindowUnsafe, getContentWindowUnchecked, js_setLocation,
+        setLocation, js_getLocation, getLocation, getLocationUnsafe,
+        getLocationUnchecked, js_getWidth, getWidth, js_getHeight,
+        getHeight, HTMLFrameElement(..), gTypeHTMLFrameElement)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -32,6 +39,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"getSVGDocument\"]()"
         js_getSVGDocument :: HTMLFrameElement -> IO (Nullable SVGDocument)
@@ -47,6 +64,14 @@
 getSVGDocument_ self = liftIO (void (js_getSVGDocument (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLFrameElement.getSVGDocument Mozilla HTMLFrameElement.getSVGDocument documentation> 
+getSVGDocumentUnsafe ::
+                     (MonadIO m, HasCallStack) => HTMLFrameElement -> m SVGDocument
+getSVGDocumentUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getSVGDocument (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLFrameElement.getSVGDocument Mozilla HTMLFrameElement.getSVGDocument documentation> 
 getSVGDocumentUnchecked ::
                         (MonadIO m) => HTMLFrameElement -> m SVGDocument
 getSVGDocumentUnchecked self
@@ -199,6 +224,14 @@
   = liftIO (nullableToMaybe <$> (js_getContentDocument (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLFrameElement.contentDocument Mozilla HTMLFrameElement.contentDocument documentation> 
+getContentDocumentUnsafe ::
+                         (MonadIO m, HasCallStack) => HTMLFrameElement -> m Document
+getContentDocumentUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getContentDocument (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLFrameElement.contentDocument Mozilla HTMLFrameElement.contentDocument documentation> 
 getContentDocumentUnchecked ::
                             (MonadIO m) => HTMLFrameElement -> m Document
 getContentDocumentUnchecked self
@@ -215,6 +248,14 @@
   = liftIO (nullableToMaybe <$> (js_getContentWindow (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLFrameElement.contentWindow Mozilla HTMLFrameElement.contentWindow documentation> 
+getContentWindowUnsafe ::
+                       (MonadIO m, HasCallStack) => HTMLFrameElement -> m Window
+getContentWindowUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getContentWindow (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLFrameElement.contentWindow Mozilla HTMLFrameElement.contentWindow documentation> 
 getContentWindowUnchecked ::
                           (MonadIO m) => HTMLFrameElement -> m Window
 getContentWindowUnchecked self
@@ -240,6 +281,15 @@
               HTMLFrameElement -> m (Maybe result)
 getLocation self
   = liftIO (fromMaybeJSString <$> (js_getLocation (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLFrameElement.location Mozilla HTMLFrameElement.location documentation> 
+getLocationUnsafe ::
+                  (MonadIO m, HasCallStack, FromJSString result) =>
+                    HTMLFrameElement -> m result
+getLocationUnsafe self
+  = liftIO
+      ((fromMaybeJSString <$> (js_getLocation (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLFrameElement.location Mozilla HTMLFrameElement.location documentation> 
 getLocationUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/HTMLFrameSetElement.hs b/src/GHCJS/DOM/JSFFI/Generated/HTMLFrameSetElement.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/HTMLFrameSetElement.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/HTMLFrameSetElement.hs
@@ -1,12 +1,18 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.HTMLFrameSetElement
        (js_setCols, setCols, js_getCols, getCols, js_setRows, setRows,
         js_getRows, getRows, beforeUnload, hashChange, message, offline,
         online, popState, resize, storage, unload, orientationChange, blur,
-        error, focus, load, HTMLFrameSetElement, castToHTMLFrameSetElement,
+        error, focus, load, HTMLFrameSetElement(..),
         gTypeHTMLFrameSetElement)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -22,6 +28,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"cols\"] = $2;" js_setCols ::
         HTMLFrameSetElement -> JSString -> IO ()
diff --git a/src/GHCJS/DOM/JSFFI/Generated/HTMLHRElement.hs b/src/GHCJS/DOM/JSFFI/Generated/HTMLHRElement.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/HTMLHRElement.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/HTMLHRElement.hs
@@ -1,11 +1,17 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.HTMLHRElement
        (js_setAlign, setAlign, js_getAlign, getAlign, js_setNoShade,
         setNoShade, js_getNoShade, getNoShade, js_setSize, setSize,
         js_getSize, getSize, js_setWidth, setWidth, js_getWidth, getWidth,
-        HTMLHRElement, castToHTMLHRElement, gTypeHTMLHRElement)
+        HTMLHRElement(..), gTypeHTMLHRElement)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -21,6 +27,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"align\"] = $2;" js_setAlign
         :: HTMLHRElement -> JSString -> IO ()
diff --git a/src/GHCJS/DOM/JSFFI/Generated/HTMLHeadElement.hs b/src/GHCJS/DOM/JSFFI/Generated/HTMLHeadElement.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/HTMLHeadElement.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/HTMLHeadElement.hs
@@ -1,9 +1,15 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.HTMLHeadElement
        (js_setProfile, setProfile, js_getProfile, getProfile,
-        HTMLHeadElement, castToHTMLHeadElement, gTypeHTMLHeadElement)
+        HTMLHeadElement(..), gTypeHTMLHeadElement)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -19,6 +25,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"profile\"] = $2;"
         js_setProfile :: HTMLHeadElement -> JSString -> IO ()
diff --git a/src/GHCJS/DOM/JSFFI/Generated/HTMLHeadingElement.hs b/src/GHCJS/DOM/JSFFI/Generated/HTMLHeadingElement.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/HTMLHeadingElement.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/HTMLHeadingElement.hs
@@ -1,9 +1,15 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.HTMLHeadingElement
-       (js_setAlign, setAlign, js_getAlign, getAlign, HTMLHeadingElement,
-        castToHTMLHeadingElement, gTypeHTMLHeadingElement)
+       (js_setAlign, setAlign, js_getAlign, getAlign,
+        HTMLHeadingElement(..), gTypeHTMLHeadingElement)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -19,6 +25,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"align\"] = $2;" js_setAlign
         :: HTMLHeadingElement -> JSString -> IO ()
diff --git a/src/GHCJS/DOM/JSFFI/Generated/HTMLHtmlElement.hs b/src/GHCJS/DOM/JSFFI/Generated/HTMLHtmlElement.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/HTMLHtmlElement.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/HTMLHtmlElement.hs
@@ -1,10 +1,16 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.HTMLHtmlElement
        (js_setVersion, setVersion, js_getVersion, getVersion,
         js_setManifest, setManifest, js_getManifest, getManifest,
-        HTMLHtmlElement, castToHTMLHtmlElement, gTypeHTMLHtmlElement)
+        HTMLHtmlElement(..), gTypeHTMLHtmlElement)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -20,6 +26,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"version\"] = $2;"
         js_setVersion :: HTMLHtmlElement -> JSString -> IO ()
diff --git a/src/GHCJS/DOM/JSFFI/Generated/HTMLIFrameElement.hs b/src/GHCJS/DOM/JSFFI/Generated/HTMLIFrameElement.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/HTMLIFrameElement.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/HTMLIFrameElement.hs
@@ -1,23 +1,31 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.HTMLIFrameElement
        (js_getSVGDocument, getSVGDocument, getSVGDocument_,
-        getSVGDocumentUnchecked, js_setAlign, setAlign, js_getAlign,
-        getAlign, js_setFrameBorder, setFrameBorder, js_getFrameBorder,
-        getFrameBorder, js_setHeight, setHeight, js_getHeight, getHeight,
-        js_setLongDesc, setLongDesc, js_getLongDesc, getLongDesc,
-        js_setMarginHeight, setMarginHeight, js_getMarginHeight,
-        getMarginHeight, js_setMarginWidth, setMarginWidth,
-        js_getMarginWidth, getMarginWidth, js_setName, setName, js_getName,
-        getName, js_setSandbox, setSandbox, js_getSandbox, getSandbox,
-        js_setScrolling, setScrolling, js_getScrolling, getScrolling,
-        js_setSrc, setSrc, js_getSrc, getSrc, js_setSrcdoc, setSrcdoc,
-        js_getSrcdoc, getSrcdoc, js_setWidth, setWidth, js_getWidth,
-        getWidth, js_getContentDocument, getContentDocument,
-        getContentDocumentUnchecked, js_getContentWindow, getContentWindow,
-        getContentWindowUnchecked, HTMLIFrameElement,
-        castToHTMLIFrameElement, gTypeHTMLIFrameElement)
+        getSVGDocumentUnsafe, getSVGDocumentUnchecked, js_setAlign,
+        setAlign, js_getAlign, getAlign, js_setFrameBorder, setFrameBorder,
+        js_getFrameBorder, getFrameBorder, js_setHeight, setHeight,
+        js_getHeight, getHeight, js_setLongDesc, setLongDesc,
+        js_getLongDesc, getLongDesc, js_setMarginHeight, setMarginHeight,
+        js_getMarginHeight, getMarginHeight, js_setMarginWidth,
+        setMarginWidth, js_getMarginWidth, getMarginWidth, js_setName,
+        setName, js_getName, getName, js_setSandbox, setSandbox,
+        js_getSandbox, getSandbox, js_setScrolling, setScrolling,
+        js_getScrolling, getScrolling, js_setSrc, setSrc, js_getSrc,
+        getSrc, js_setSrcdoc, setSrcdoc, js_getSrcdoc, getSrcdoc,
+        js_setWidth, setWidth, js_getWidth, getWidth,
+        js_getContentDocument, getContentDocument,
+        getContentDocumentUnsafe, getContentDocumentUnchecked,
+        js_getContentWindow, getContentWindow, getContentWindowUnsafe,
+        getContentWindowUnchecked, HTMLIFrameElement(..),
+        gTypeHTMLIFrameElement)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -33,6 +41,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"getSVGDocument\"]()"
         js_getSVGDocument :: HTMLIFrameElement -> IO (Nullable SVGDocument)
@@ -48,6 +66,14 @@
 getSVGDocument_ self = liftIO (void (js_getSVGDocument (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLIFrameElement.getSVGDocument Mozilla HTMLIFrameElement.getSVGDocument documentation> 
+getSVGDocumentUnsafe ::
+                     (MonadIO m, HasCallStack) => HTMLIFrameElement -> m SVGDocument
+getSVGDocumentUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getSVGDocument (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLIFrameElement.getSVGDocument Mozilla HTMLIFrameElement.getSVGDocument documentation> 
 getSVGDocumentUnchecked ::
                         (MonadIO m) => HTMLIFrameElement -> m SVGDocument
 getSVGDocumentUnchecked self
@@ -268,6 +294,14 @@
   = liftIO (nullableToMaybe <$> (js_getContentDocument (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLIFrameElement.contentDocument Mozilla HTMLIFrameElement.contentDocument documentation> 
+getContentDocumentUnsafe ::
+                         (MonadIO m, HasCallStack) => HTMLIFrameElement -> m Document
+getContentDocumentUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getContentDocument (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLIFrameElement.contentDocument Mozilla HTMLIFrameElement.contentDocument documentation> 
 getContentDocumentUnchecked ::
                             (MonadIO m) => HTMLIFrameElement -> m Document
 getContentDocumentUnchecked self
@@ -282,6 +316,14 @@
                  (MonadIO m) => HTMLIFrameElement -> m (Maybe Window)
 getContentWindow self
   = liftIO (nullableToMaybe <$> (js_getContentWindow (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLIFrameElement.contentWindow Mozilla HTMLIFrameElement.contentWindow documentation> 
+getContentWindowUnsafe ::
+                       (MonadIO m, HasCallStack) => HTMLIFrameElement -> m Window
+getContentWindowUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getContentWindow (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLIFrameElement.contentWindow Mozilla HTMLIFrameElement.contentWindow documentation> 
 getContentWindowUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/HTMLImageElement.hs b/src/GHCJS/DOM/JSFFI/Generated/HTMLImageElement.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/HTMLImageElement.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/HTMLImageElement.hs
@@ -1,4 +1,9 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.HTMLImageElement
        (js_setName, setName, js_getName, getName, js_setAlign, setAlign,
         js_getAlign, getAlign, js_setAlt, setAlt, js_getAlt, getAlt,
@@ -15,10 +20,10 @@
         js_getWidth, getWidth, js_getComplete, getComplete, js_setLowsrc,
         setLowsrc, js_getLowsrc, getLowsrc, js_getNaturalHeight,
         getNaturalHeight, js_getNaturalWidth, getNaturalWidth, js_getX,
-        getX, js_getY, getY, HTMLImageElement, castToHTMLImageElement,
-        gTypeHTMLImageElement)
+        getX, js_getY, getY, HTMLImageElement(..), gTypeHTMLImageElement)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -34,6 +39,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"name\"] = $2;" js_setName ::
         HTMLImageElement -> JSString -> IO ()
diff --git a/src/GHCJS/DOM/JSFFI/Generated/HTMLInputElement.hs b/src/GHCJS/DOM/JSFFI/Generated/HTMLInputElement.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/HTMLInputElement.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/HTMLInputElement.hs
@@ -1,4 +1,9 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.HTMLInputElement
        (js_stepUp, stepUp, js_stepDown, stepDown, js_checkValidity,
         checkValidity, checkValidity_, js_setCustomValidity,
@@ -12,52 +17,57 @@
         js_getDefaultChecked, getDefaultChecked, js_setChecked, setChecked,
         js_getChecked, getChecked, js_setDirName, setDirName,
         js_getDirName, getDirName, js_setDisabled, setDisabled,
-        js_getDisabled, getDisabled, js_getForm, getForm, getFormUnchecked,
-        js_setFiles, setFiles, js_getFiles, getFiles, getFilesUnchecked,
-        js_setFormAction, setFormAction, js_getFormAction, getFormAction,
-        js_setFormEnctype, setFormEnctype, js_getFormEnctype,
-        getFormEnctype, getFormEnctypeUnchecked, js_setFormMethod,
-        setFormMethod, js_getFormMethod, getFormMethod,
+        js_getDisabled, getDisabled, js_getForm, getForm, getFormUnsafe,
+        getFormUnchecked, js_setFiles, setFiles, js_getFiles, getFiles,
+        getFilesUnsafe, getFilesUnchecked, js_setFormAction, setFormAction,
+        js_getFormAction, getFormAction, js_setFormEnctype, setFormEnctype,
+        js_getFormEnctype, getFormEnctype, getFormEnctypeUnsafe,
+        getFormEnctypeUnchecked, js_setFormMethod, setFormMethod,
+        js_getFormMethod, getFormMethod, getFormMethodUnsafe,
         getFormMethodUnchecked, js_setFormNoValidate, setFormNoValidate,
         js_getFormNoValidate, getFormNoValidate, js_setFormTarget,
         setFormTarget, js_getFormTarget, getFormTarget, js_setHeight,
         setHeight, js_getHeight, getHeight, js_setIndeterminate,
         setIndeterminate, js_getIndeterminate, getIndeterminate,
-        js_getList, getList, getListUnchecked, js_setMax, setMax,
-        js_getMax, getMax, js_setMaxLength, setMaxLength, js_getMaxLength,
-        getMaxLength, js_setMin, setMin, js_getMin, getMin, js_setMultiple,
-        setMultiple, js_getMultiple, getMultiple, js_setName, setName,
-        js_getName, getName, js_setPattern, setPattern, js_getPattern,
-        getPattern, js_setPlaceholder, setPlaceholder, js_getPlaceholder,
-        getPlaceholder, js_setReadOnly, setReadOnly, js_getReadOnly,
-        getReadOnly, js_setRequired, setRequired, js_getRequired,
-        getRequired, js_setSize, setSize, js_getSize, getSize, js_setSrc,
-        setSrc, js_getSrc, getSrc, js_setStep, setStep, js_getStep,
-        getStep, js_setType, setType, js_getType, getType,
-        js_setDefaultValue, setDefaultValue, js_getDefaultValue,
-        getDefaultValue, getDefaultValueUnchecked, js_setValue, setValue,
-        js_getValue, getValue, getValueUnchecked, js_setValueAsDate,
+        js_getList, getList, getListUnsafe, getListUnchecked, js_setMax,
+        setMax, js_getMax, getMax, js_setMaxLength, setMaxLength,
+        js_getMaxLength, getMaxLength, js_setMin, setMin, js_getMin,
+        getMin, js_setMultiple, setMultiple, js_getMultiple, getMultiple,
+        js_setName, setName, js_getName, getName, js_setPattern,
+        setPattern, js_getPattern, getPattern, js_setPlaceholder,
+        setPlaceholder, js_getPlaceholder, getPlaceholder, js_setReadOnly,
+        setReadOnly, js_getReadOnly, getReadOnly, js_setRequired,
+        setRequired, js_getRequired, getRequired, js_setSize, setSize,
+        js_getSize, getSize, js_setSrc, setSrc, js_getSrc, getSrc,
+        js_setStep, setStep, js_getStep, getStep, js_setType, setType,
+        js_getType, getType, js_setDefaultValue, setDefaultValue,
+        js_getDefaultValue, getDefaultValue, getDefaultValueUnsafe,
+        getDefaultValueUnchecked, js_setValue, setValue, js_getValue,
+        getValue, getValueUnsafe, getValueUnchecked, js_setValueAsDate,
         setValueAsDate, js_getValueAsDate, getValueAsDate,
-        getValueAsDateUnchecked, js_setValueAsNumber, setValueAsNumber,
-        js_getValueAsNumber, getValueAsNumber, js_setWidth, setWidth,
-        js_getWidth, getWidth, js_getWillValidate, getWillValidate,
-        js_getValidity, getValidity, getValidityUnchecked,
-        js_getValidationMessage, getValidationMessage, js_getLabels,
-        getLabels, getLabelsUnchecked, js_setSelectionStart,
-        setSelectionStart, js_getSelectionStart, getSelectionStart,
-        js_setSelectionEnd, setSelectionEnd, js_getSelectionEnd,
-        getSelectionEnd, js_setSelectionDirection, setSelectionDirection,
+        getValueAsDateUnsafe, getValueAsDateUnchecked, js_setValueAsNumber,
+        setValueAsNumber, js_getValueAsNumber, getValueAsNumber,
+        js_setWidth, setWidth, js_getWidth, getWidth, js_getWillValidate,
+        getWillValidate, js_getValidity, getValidity, getValidityUnsafe,
+        getValidityUnchecked, js_getValidationMessage,
+        getValidationMessage, js_getLabels, getLabels, getLabelsUnsafe,
+        getLabelsUnchecked, js_setSelectionStart, setSelectionStart,
+        js_getSelectionStart, getSelectionStart, js_setSelectionEnd,
+        setSelectionEnd, js_getSelectionEnd, getSelectionEnd,
+        js_setSelectionDirection, setSelectionDirection,
         js_getSelectionDirection, getSelectionDirection, js_setAlign,
         setAlign, js_getAlign, getAlign, js_setUseMap, setUseMap,
         js_getUseMap, getUseMap, js_setIncremental, setIncremental,
         js_getIncremental, getIncremental, js_setAutocorrect,
         setAutocorrect, js_getAutocorrect, getAutocorrect,
         js_setAutocapitalize, setAutocapitalize, js_getAutocapitalize,
-        getAutocapitalize, getAutocapitalizeUnchecked, js_setCapture,
-        setCapture, js_getCapture, getCapture, HTMLInputElement,
-        castToHTMLInputElement, gTypeHTMLInputElement)
+        getAutocapitalize, getAutocapitalizeUnsafe,
+        getAutocapitalizeUnchecked, js_setCapture, setCapture,
+        js_getCapture, getCapture, HTMLInputElement(..),
+        gTypeHTMLInputElement)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -73,6 +83,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"stepUp\"]($2)" js_stepUp ::
         HTMLInputElement -> Int -> IO ()
@@ -288,6 +308,14 @@
 getForm self = liftIO (nullableToMaybe <$> (js_getForm (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLInputElement.form Mozilla HTMLInputElement.form documentation> 
+getFormUnsafe ::
+              (MonadIO m, HasCallStack) => HTMLInputElement -> m HTMLFormElement
+getFormUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getForm (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLInputElement.form Mozilla HTMLInputElement.form documentation> 
 getFormUnchecked ::
                  (MonadIO m) => HTMLInputElement -> m HTMLFormElement
 getFormUnchecked self
@@ -310,6 +338,14 @@
 getFiles self = liftIO (nullableToMaybe <$> (js_getFiles (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLInputElement.files Mozilla HTMLInputElement.files documentation> 
+getFilesUnsafe ::
+               (MonadIO m, HasCallStack) => HTMLInputElement -> m FileList
+getFilesUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getFiles (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLInputElement.files Mozilla HTMLInputElement.files documentation> 
 getFilesUnchecked :: (MonadIO m) => HTMLInputElement -> m FileList
 getFilesUnchecked self
   = liftIO (fromJust . nullableToMaybe <$> (js_getFiles (self)))
@@ -353,6 +389,15 @@
   = liftIO (fromMaybeJSString <$> (js_getFormEnctype (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLInputElement.formEnctype Mozilla HTMLInputElement.formEnctype documentation> 
+getFormEnctypeUnsafe ::
+                     (MonadIO m, HasCallStack, FromJSString result) =>
+                       HTMLInputElement -> m result
+getFormEnctypeUnsafe self
+  = liftIO
+      ((fromMaybeJSString <$> (js_getFormEnctype (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLInputElement.formEnctype Mozilla HTMLInputElement.formEnctype documentation> 
 getFormEnctypeUnchecked ::
                         (MonadIO m, FromJSString result) => HTMLInputElement -> m result
 getFormEnctypeUnchecked self
@@ -380,6 +425,15 @@
   = liftIO (fromMaybeJSString <$> (js_getFormMethod (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLInputElement.formMethod Mozilla HTMLInputElement.formMethod documentation> 
+getFormMethodUnsafe ::
+                    (MonadIO m, HasCallStack, FromJSString result) =>
+                      HTMLInputElement -> m result
+getFormMethodUnsafe self
+  = liftIO
+      ((fromMaybeJSString <$> (js_getFormMethod (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLInputElement.formMethod Mozilla HTMLInputElement.formMethod documentation> 
 getFormMethodUnchecked ::
                        (MonadIO m, FromJSString result) => HTMLInputElement -> m result
 getFormMethodUnchecked self
@@ -456,6 +510,14 @@
 getList self = liftIO (nullableToMaybe <$> (js_getList (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLInputElement.list Mozilla HTMLInputElement.list documentation> 
+getListUnsafe ::
+              (MonadIO m, HasCallStack) => HTMLInputElement -> m HTMLElement
+getListUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getList (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLInputElement.list Mozilla HTMLInputElement.list documentation> 
 getListUnchecked ::
                  (MonadIO m) => HTMLInputElement -> m HTMLElement
 getListUnchecked self
@@ -684,6 +746,15 @@
   = liftIO (fromMaybeJSString <$> (js_getDefaultValue (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLInputElement.defaultValue Mozilla HTMLInputElement.defaultValue documentation> 
+getDefaultValueUnsafe ::
+                      (MonadIO m, HasCallStack, FromJSString result) =>
+                        HTMLInputElement -> m result
+getDefaultValueUnsafe self
+  = liftIO
+      ((fromMaybeJSString <$> (js_getDefaultValue (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLInputElement.defaultValue Mozilla HTMLInputElement.defaultValue documentation> 
 getDefaultValueUnchecked ::
                          (MonadIO m, FromJSString result) => HTMLInputElement -> m result
 getDefaultValueUnchecked self
@@ -710,6 +781,15 @@
 getValue self = liftIO (fromMaybeJSString <$> (js_getValue (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLInputElement.value Mozilla HTMLInputElement.value documentation> 
+getValueUnsafe ::
+               (MonadIO m, HasCallStack, FromJSString result) =>
+                 HTMLInputElement -> m result
+getValueUnsafe self
+  = liftIO
+      ((fromMaybeJSString <$> (js_getValue (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLInputElement.value Mozilla HTMLInputElement.value documentation> 
 getValueUnchecked ::
                   (MonadIO m, FromJSString result) => HTMLInputElement -> m result
 getValueUnchecked self
@@ -734,6 +814,14 @@
   = liftIO (nullableToMaybe <$> (js_getValueAsDate (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLInputElement.valueAsDate Mozilla HTMLInputElement.valueAsDate documentation> 
+getValueAsDateUnsafe ::
+                     (MonadIO m, HasCallStack) => HTMLInputElement -> m Date
+getValueAsDateUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getValueAsDate (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLInputElement.valueAsDate Mozilla HTMLInputElement.valueAsDate documentation> 
 getValueAsDateUnchecked ::
                         (MonadIO m) => HTMLInputElement -> m Date
 getValueAsDateUnchecked self
@@ -786,6 +874,14 @@
   = liftIO (nullableToMaybe <$> (js_getValidity (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLInputElement.validity Mozilla HTMLInputElement.validity documentation> 
+getValidityUnsafe ::
+                  (MonadIO m, HasCallStack) => HTMLInputElement -> m ValidityState
+getValidityUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getValidity (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLInputElement.validity Mozilla HTMLInputElement.validity documentation> 
 getValidityUnchecked ::
                      (MonadIO m) => HTMLInputElement -> m ValidityState
 getValidityUnchecked self
@@ -808,6 +904,14 @@
 getLabels self = liftIO (nullableToMaybe <$> (js_getLabels (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLInputElement.labels Mozilla HTMLInputElement.labels documentation> 
+getLabelsUnsafe ::
+                (MonadIO m, HasCallStack) => HTMLInputElement -> m NodeList
+getLabelsUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getLabels (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLInputElement.labels Mozilla HTMLInputElement.labels documentation> 
 getLabelsUnchecked :: (MonadIO m) => HTMLInputElement -> m NodeList
 getLabelsUnchecked self
   = liftIO (fromJust . nullableToMaybe <$> (js_getLabels (self)))
@@ -939,6 +1043,15 @@
                     HTMLInputElement -> m (Maybe result)
 getAutocapitalize self
   = liftIO (fromMaybeJSString <$> (js_getAutocapitalize (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLInputElement.autocapitalize Mozilla HTMLInputElement.autocapitalize documentation> 
+getAutocapitalizeUnsafe ::
+                        (MonadIO m, HasCallStack, FromJSString result) =>
+                          HTMLInputElement -> m result
+getAutocapitalizeUnsafe self
+  = liftIO
+      ((fromMaybeJSString <$> (js_getAutocapitalize (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLInputElement.autocapitalize Mozilla HTMLInputElement.autocapitalize documentation> 
 getAutocapitalizeUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/HTMLKeygenElement.hs b/src/GHCJS/DOM/JSFFI/Generated/HTMLKeygenElement.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/HTMLKeygenElement.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/HTMLKeygenElement.hs
@@ -1,18 +1,25 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.HTMLKeygenElement
        (js_checkValidity, checkValidity, checkValidity_,
         js_setCustomValidity, setCustomValidity, js_setAutofocus,
         setAutofocus, js_getAutofocus, getAutofocus, js_setChallenge,
         setChallenge, js_getChallenge, getChallenge, js_setDisabled,
         setDisabled, js_getDisabled, getDisabled, js_getForm, getForm,
-        getFormUnchecked, js_setKeytype, setKeytype, js_getKeytype,
-        getKeytype, js_setName, setName, js_getName, getName, js_getType,
-        getType, js_getWillValidate, getWillValidate, js_getValidity,
-        getValidity, getValidityUnchecked, js_getValidationMessage,
-        getValidationMessage, js_getLabels, getLabels, getLabelsUnchecked,
-        HTMLKeygenElement, castToHTMLKeygenElement, gTypeHTMLKeygenElement)
+        getFormUnsafe, getFormUnchecked, js_setKeytype, setKeytype,
+        js_getKeytype, getKeytype, js_setName, setName, js_getName,
+        getName, js_getType, getType, js_getWillValidate, getWillValidate,
+        js_getValidity, getValidity, getValidityUnsafe,
+        getValidityUnchecked, js_getValidationMessage,
+        getValidationMessage, js_getLabels, getLabels, getLabelsUnsafe,
+        getLabelsUnchecked, HTMLKeygenElement(..), gTypeHTMLKeygenElement)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -28,6 +35,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe
         "($1[\"checkValidity\"]() ? 1 : 0)" js_checkValidity ::
@@ -107,6 +124,14 @@
 getForm self = liftIO (nullableToMaybe <$> (js_getForm (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLKeygenElement.form Mozilla HTMLKeygenElement.form documentation> 
+getFormUnsafe ::
+              (MonadIO m, HasCallStack) => HTMLKeygenElement -> m HTMLFormElement
+getFormUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getForm (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLKeygenElement.form Mozilla HTMLKeygenElement.form documentation> 
 getFormUnchecked ::
                  (MonadIO m) => HTMLKeygenElement -> m HTMLFormElement
 getFormUnchecked self
@@ -170,6 +195,14 @@
   = liftIO (nullableToMaybe <$> (js_getValidity (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLKeygenElement.validity Mozilla HTMLKeygenElement.validity documentation> 
+getValidityUnsafe ::
+                  (MonadIO m, HasCallStack) => HTMLKeygenElement -> m ValidityState
+getValidityUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getValidity (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLKeygenElement.validity Mozilla HTMLKeygenElement.validity documentation> 
 getValidityUnchecked ::
                      (MonadIO m) => HTMLKeygenElement -> m ValidityState
 getValidityUnchecked self
@@ -190,6 +223,14 @@
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLKeygenElement.labels Mozilla HTMLKeygenElement.labels documentation> 
 getLabels :: (MonadIO m) => HTMLKeygenElement -> m (Maybe NodeList)
 getLabels self = liftIO (nullableToMaybe <$> (js_getLabels (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLKeygenElement.labels Mozilla HTMLKeygenElement.labels documentation> 
+getLabelsUnsafe ::
+                (MonadIO m, HasCallStack) => HTMLKeygenElement -> m NodeList
+getLabelsUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getLabels (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLKeygenElement.labels Mozilla HTMLKeygenElement.labels documentation> 
 getLabelsUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/HTMLLIElement.hs b/src/GHCJS/DOM/JSFFI/Generated/HTMLLIElement.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/HTMLLIElement.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/HTMLLIElement.hs
@@ -1,10 +1,15 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.HTMLLIElement
        (js_setType, setType, js_getType, getType, js_setValue, setValue,
-        js_getValue, getValue, HTMLLIElement, castToHTMLLIElement,
-        gTypeHTMLLIElement)
+        js_getValue, getValue, HTMLLIElement(..), gTypeHTMLLIElement)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -20,6 +25,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"type\"] = $2;" js_setType ::
         HTMLLIElement -> JSString -> IO ()
diff --git a/src/GHCJS/DOM/JSFFI/Generated/HTMLLabelElement.hs b/src/GHCJS/DOM/JSFFI/Generated/HTMLLabelElement.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/HTMLLabelElement.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/HTMLLabelElement.hs
@@ -1,11 +1,17 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.HTMLLabelElement
-       (js_getForm, getForm, getFormUnchecked, js_setHtmlFor, setHtmlFor,
-        js_getHtmlFor, getHtmlFor, js_getControl, getControl,
-        getControlUnchecked, HTMLLabelElement, castToHTMLLabelElement,
-        gTypeHTMLLabelElement)
+       (js_getForm, getForm, getFormUnsafe, getFormUnchecked,
+        js_setHtmlFor, setHtmlFor, js_getHtmlFor, getHtmlFor,
+        js_getControl, getControl, getControlUnsafe, getControlUnchecked,
+        HTMLLabelElement(..), gTypeHTMLLabelElement)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -21,6 +27,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"form\"]" js_getForm ::
         HTMLLabelElement -> IO (Nullable HTMLFormElement)
@@ -31,6 +47,14 @@
 getForm self = liftIO (nullableToMaybe <$> (js_getForm (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLLabelElement.form Mozilla HTMLLabelElement.form documentation> 
+getFormUnsafe ::
+              (MonadIO m, HasCallStack) => HTMLLabelElement -> m HTMLFormElement
+getFormUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getForm (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLLabelElement.form Mozilla HTMLLabelElement.form documentation> 
 getFormUnchecked ::
                  (MonadIO m) => HTMLLabelElement -> m HTMLFormElement
 getFormUnchecked self
@@ -61,6 +85,14 @@
            (MonadIO m) => HTMLLabelElement -> m (Maybe HTMLElement)
 getControl self
   = liftIO (nullableToMaybe <$> (js_getControl (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLLabelElement.control Mozilla HTMLLabelElement.control documentation> 
+getControlUnsafe ::
+                 (MonadIO m, HasCallStack) => HTMLLabelElement -> m HTMLElement
+getControlUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getControl (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLLabelElement.control Mozilla HTMLLabelElement.control documentation> 
 getControlUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/HTMLLegendElement.hs b/src/GHCJS/DOM/JSFFI/Generated/HTMLLegendElement.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/HTMLLegendElement.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/HTMLLegendElement.hs
@@ -1,10 +1,16 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.HTMLLegendElement
-       (js_getForm, getForm, getFormUnchecked, js_setAlign, setAlign,
-        js_getAlign, getAlign, HTMLLegendElement, castToHTMLLegendElement,
+       (js_getForm, getForm, getFormUnsafe, getFormUnchecked, js_setAlign,
+        setAlign, js_getAlign, getAlign, HTMLLegendElement(..),
         gTypeHTMLLegendElement)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -20,6 +26,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"form\"]" js_getForm ::
         HTMLLegendElement -> IO (Nullable HTMLFormElement)
@@ -28,6 +44,14 @@
 getForm ::
         (MonadIO m) => HTMLLegendElement -> m (Maybe HTMLFormElement)
 getForm self = liftIO (nullableToMaybe <$> (js_getForm (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLLegendElement.form Mozilla HTMLLegendElement.form documentation> 
+getFormUnsafe ::
+              (MonadIO m, HasCallStack) => HTMLLegendElement -> m HTMLFormElement
+getFormUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getForm (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLLegendElement.form Mozilla HTMLLegendElement.form documentation> 
 getFormUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/HTMLLinkElement.hs b/src/GHCJS/DOM/JSFFI/Generated/HTMLLinkElement.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/HTMLLinkElement.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/HTMLLinkElement.hs
@@ -1,4 +1,9 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.HTMLLinkElement
        (js_setDisabled, setDisabled, js_getDisabled, getDisabled,
         js_setCharset, setCharset, js_getCharset, getCharset, js_setHref,
@@ -6,13 +11,14 @@
         js_getHreflang, getHreflang, js_setMedia, setMedia, js_getMedia,
         getMedia, js_setRel, setRel, js_getRel, getRel, js_setRev, setRev,
         js_getRev, getRev, js_setSizes, setSizes, js_getSizes, getSizes,
-        getSizesUnchecked, js_setTarget, setTarget, js_getTarget,
-        getTarget, js_setType, setType, js_getType, getType, js_getSheet,
-        getSheet, getSheetUnchecked, js_getRelList, getRelList,
-        getRelListUnchecked, HTMLLinkElement, castToHTMLLinkElement,
-        gTypeHTMLLinkElement)
+        getSizesUnsafe, getSizesUnchecked, js_setTarget, setTarget,
+        js_getTarget, getTarget, js_setType, setType, js_getType, getType,
+        js_getSheet, getSheet, getSheetUnsafe, getSheetUnchecked,
+        js_getRelList, getRelList, getRelListUnsafe, getRelListUnchecked,
+        HTMLLinkElement(..), gTypeHTMLLinkElement)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -28,6 +34,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"disabled\"] = $2;"
         js_setDisabled :: HTMLLinkElement -> Bool -> IO ()
@@ -161,6 +177,15 @@
 getSizes self = liftIO (nullableToMaybe <$> (js_getSizes (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLLinkElement.sizes Mozilla HTMLLinkElement.sizes documentation> 
+getSizesUnsafe ::
+               (MonadIO m, HasCallStack) =>
+                 HTMLLinkElement -> m DOMSettableTokenList
+getSizesUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getSizes (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLLinkElement.sizes Mozilla HTMLLinkElement.sizes documentation> 
 getSizesUnchecked ::
                   (MonadIO m) => HTMLLinkElement -> m DOMSettableTokenList
 getSizesUnchecked self
@@ -206,6 +231,14 @@
 getSheet self = liftIO (nullableToMaybe <$> (js_getSheet (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLLinkElement.sheet Mozilla HTMLLinkElement.sheet documentation> 
+getSheetUnsafe ::
+               (MonadIO m, HasCallStack) => HTMLLinkElement -> m StyleSheet
+getSheetUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getSheet (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLLinkElement.sheet Mozilla HTMLLinkElement.sheet documentation> 
 getSheetUnchecked :: (MonadIO m) => HTMLLinkElement -> m StyleSheet
 getSheetUnchecked self
   = liftIO (fromJust . nullableToMaybe <$> (js_getSheet (self)))
@@ -218,6 +251,14 @@
            (MonadIO m) => HTMLLinkElement -> m (Maybe DOMTokenList)
 getRelList self
   = liftIO (nullableToMaybe <$> (js_getRelList (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLLinkElement.relList Mozilla HTMLLinkElement.relList documentation> 
+getRelListUnsafe ::
+                 (MonadIO m, HasCallStack) => HTMLLinkElement -> m DOMTokenList
+getRelListUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getRelList (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLLinkElement.relList Mozilla HTMLLinkElement.relList documentation> 
 getRelListUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/HTMLMapElement.hs b/src/GHCJS/DOM/JSFFI/Generated/HTMLMapElement.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/HTMLMapElement.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/HTMLMapElement.hs
@@ -1,10 +1,16 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.HTMLMapElement
-       (js_getAreas, getAreas, getAreasUnchecked, js_setName, setName,
-        js_getName, getName, HTMLMapElement, castToHTMLMapElement,
+       (js_getAreas, getAreas, getAreasUnsafe, getAreasUnchecked,
+        js_setName, setName, js_getName, getName, HTMLMapElement(..),
         gTypeHTMLMapElement)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -20,6 +26,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"areas\"]" js_getAreas ::
         HTMLMapElement -> IO (Nullable HTMLCollection)
@@ -28,6 +44,14 @@
 getAreas ::
          (MonadIO m) => HTMLMapElement -> m (Maybe HTMLCollection)
 getAreas self = liftIO (nullableToMaybe <$> (js_getAreas (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLMapElement.areas Mozilla HTMLMapElement.areas documentation> 
+getAreasUnsafe ::
+               (MonadIO m, HasCallStack) => HTMLMapElement -> m HTMLCollection
+getAreasUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getAreas (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLMapElement.areas Mozilla HTMLMapElement.areas documentation> 
 getAreasUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/HTMLMarqueeElement.hs b/src/GHCJS/DOM/JSFFI/Generated/HTMLMarqueeElement.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/HTMLMarqueeElement.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/HTMLMarqueeElement.hs
@@ -1,4 +1,9 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.HTMLMarqueeElement
        (js_start, start, js_stop, stop, js_setBehavior, setBehavior,
         js_getBehavior, getBehavior, js_setBgColor, setBgColor,
@@ -11,10 +16,10 @@
         js_getScrollDelay, getScrollDelay, js_setTrueSpeed, setTrueSpeed,
         js_getTrueSpeed, getTrueSpeed, js_setVspace, setVspace,
         js_getVspace, getVspace, js_setWidth, setWidth, js_getWidth,
-        getWidth, HTMLMarqueeElement, castToHTMLMarqueeElement,
-        gTypeHTMLMarqueeElement)
+        getWidth, HTMLMarqueeElement(..), gTypeHTMLMarqueeElement)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -30,6 +35,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"start\"]()" js_start ::
         HTMLMarqueeElement -> IO ()
diff --git a/src/GHCJS/DOM/JSFFI/Generated/HTMLMediaElement.hs b/src/GHCJS/DOM/JSFFI/Generated/HTMLMediaElement.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/HTMLMediaElement.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/HTMLMediaElement.hs
@@ -1,23 +1,29 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.HTMLMediaElement
        (js_load, load, js_canPlayType, canPlayType, canPlayType_, js_play,
         play, js_pause, pause, js_fastSeek, fastSeek,
         js_webkitGenerateKeyRequest, webkitGenerateKeyRequest,
         js_webkitAddKey, webkitAddKey, js_webkitCancelKeyRequest,
         webkitCancelKeyRequest, js_webkitSetMediaKeys, webkitSetMediaKeys,
-        js_addTextTrack, addTextTrack, addTextTrack_,
+        js_addTextTrack, addTextTrack, addTextTrack_, addTextTrackUnsafe,
         addTextTrackUnchecked, js_getVideoPlaybackQuality,
         getVideoPlaybackQuality, getVideoPlaybackQuality_,
-        getVideoPlaybackQualityUnchecked,
+        getVideoPlaybackQualityUnsafe, getVideoPlaybackQualityUnchecked,
         js_webkitShowPlaybackTargetPicker, webkitShowPlaybackTargetPicker,
         pattern NETWORK_EMPTY, pattern NETWORK_IDLE,
         pattern NETWORK_LOADING, pattern NETWORK_NO_SOURCE,
         pattern HAVE_NOTHING, pattern HAVE_METADATA,
         pattern HAVE_CURRENT_DATA, pattern HAVE_FUTURE_DATA,
-        pattern HAVE_ENOUGH_DATA, js_getError, getError, getErrorUnchecked,
-        js_setSrc, setSrc, js_getSrc, getSrc, js_getCurrentSrc,
-        getCurrentSrc, js_getNetworkState, getNetworkState, js_setPreload,
-        setPreload, js_getPreload, getPreload, js_getBuffered, getBuffered,
+        pattern HAVE_ENOUGH_DATA, js_getError, getError, getErrorUnsafe,
+        getErrorUnchecked, js_setSrc, setSrc, js_getSrc, getSrc,
+        js_getCurrentSrc, getCurrentSrc, js_getNetworkState,
+        getNetworkState, js_setPreload, setPreload, js_getPreload,
+        getPreload, js_getBuffered, getBuffered, getBufferedUnsafe,
         getBufferedUnchecked, js_getReadyState, getReadyState,
         js_getSeeking, getSeeking, js_setCurrentTime, setCurrentTime,
         js_getCurrentTime, getCurrentTime, js_getDuration, getDuration,
@@ -25,40 +31,44 @@
         setDefaultPlaybackRate, js_getDefaultPlaybackRate,
         getDefaultPlaybackRate, js_setPlaybackRate, setPlaybackRate,
         js_getPlaybackRate, getPlaybackRate, js_getPlayed, getPlayed,
-        getPlayedUnchecked, js_getSeekable, getSeekable,
-        getSeekableUnchecked, js_getEnded, getEnded, js_setAutoplay,
-        setAutoplay, js_getAutoplay, getAutoplay, js_setLoop, setLoop,
-        js_getLoop, getLoop, js_setControls, setControls, js_getControls,
-        getControls, js_setVolume, setVolume, js_getVolume, getVolume,
-        js_setMuted, setMuted, js_getMuted, getMuted, js_setDefaultMuted,
-        setDefaultMuted, js_getDefaultMuted, getDefaultMuted, emptied,
-        loadedMetadata, loadedData, canPlay, canPlayThrough, playing,
-        ended, waiting, durationChange, timeUpdate, playEvent, pauseEvent,
-        rateChange, volumeChange, js_setWebkitPreservesPitch,
-        setWebkitPreservesPitch, js_getWebkitPreservesPitch,
-        getWebkitPreservesPitch, js_getWebkitHasClosedCaptions,
-        getWebkitHasClosedCaptions, js_setWebkitClosedCaptionsVisible,
-        setWebkitClosedCaptionsVisible, js_getWebkitClosedCaptionsVisible,
-        getWebkitClosedCaptionsVisible, js_getWebkitAudioDecodedByteCount,
-        getWebkitAudioDecodedByteCount, js_getWebkitVideoDecodedByteCount,
-        getWebkitVideoDecodedByteCount, webKitKeyAdded, webKitKeyError,
-        webKitKeyMessage, webKitNeedKey, js_getWebkitKeys, getWebkitKeys,
+        getPlayedUnsafe, getPlayedUnchecked, js_getSeekable, getSeekable,
+        getSeekableUnsafe, getSeekableUnchecked, js_getEnded, getEnded,
+        js_setAutoplay, setAutoplay, js_getAutoplay, getAutoplay,
+        js_setLoop, setLoop, js_getLoop, getLoop, js_setControls,
+        setControls, js_getControls, getControls, js_setVolume, setVolume,
+        js_getVolume, getVolume, js_setMuted, setMuted, js_getMuted,
+        getMuted, js_setDefaultMuted, setDefaultMuted, js_getDefaultMuted,
+        getDefaultMuted, emptied, loadedMetadata, loadedData, canPlay,
+        canPlayThrough, playing, ended, waiting, durationChange,
+        timeUpdate, playEvent, pauseEvent, rateChange, volumeChange,
+        js_setWebkitPreservesPitch, setWebkitPreservesPitch,
+        js_getWebkitPreservesPitch, getWebkitPreservesPitch,
+        js_getWebkitHasClosedCaptions, getWebkitHasClosedCaptions,
+        js_setWebkitClosedCaptionsVisible, setWebkitClosedCaptionsVisible,
+        js_getWebkitClosedCaptionsVisible, getWebkitClosedCaptionsVisible,
+        js_getWebkitAudioDecodedByteCount, getWebkitAudioDecodedByteCount,
+        js_getWebkitVideoDecodedByteCount, getWebkitVideoDecodedByteCount,
+        webKitKeyAdded, webKitKeyError, webKitKeyMessage, webKitNeedKey,
+        js_getWebkitKeys, getWebkitKeys, getWebkitKeysUnsafe,
         getWebkitKeysUnchecked, js_getAudioTracks, getAudioTracks,
-        getAudioTracksUnchecked, js_getTextTracks, getTextTracks,
-        getTextTracksUnchecked, js_getVideoTracks, getVideoTracks,
+        getAudioTracksUnsafe, getAudioTracksUnchecked, js_getTextTracks,
+        getTextTracks, getTextTracksUnsafe, getTextTracksUnchecked,
+        js_getVideoTracks, getVideoTracks, getVideoTracksUnsafe,
         getVideoTracksUnchecked, js_setMediaGroup, setMediaGroup,
-        js_getMediaGroup, getMediaGroup, getMediaGroupUnchecked,
-        js_setController, setController, js_getController, getController,
+        js_getMediaGroup, getMediaGroup, getMediaGroupUnsafe,
+        getMediaGroupUnchecked, js_setController, setController,
+        js_getController, getController, getControllerUnsafe,
         getControllerUnchecked,
         js_getWebkitCurrentPlaybackTargetIsWireless,
         getWebkitCurrentPlaybackTargetIsWireless,
         webKitCurrentPlaybackTargetIsWirelessChanged,
         webKitPlaybackTargetAvailabilityChanged, js_setSrcObject,
-        setSrcObject, js_getSrcObject, getSrcObject, getSrcObjectUnchecked,
-        HTMLMediaElement, castToHTMLMediaElement, gTypeHTMLMediaElement,
+        setSrcObject, js_getSrcObject, getSrcObject, getSrcObjectUnsafe,
+        getSrcObjectUnchecked, HTMLMediaElement(..), gTypeHTMLMediaElement,
         IsHTMLMediaElement, toHTMLMediaElement)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -74,6 +84,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"load\"]()" js_load ::
         HTMLMediaElement -> IO ()
@@ -226,6 +246,19 @@
             (toJSString language)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLMediaElement.addTextTrack Mozilla HTMLMediaElement.addTextTrack documentation> 
+addTextTrackUnsafe ::
+                   (MonadIO m, IsHTMLMediaElement self, ToJSString kind,
+                    ToJSString label, ToJSString language, HasCallStack) =>
+                     self -> kind -> label -> language -> m TextTrack
+addTextTrackUnsafe self kind label language
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_addTextTrack (toHTMLMediaElement self) (toJSString kind)
+             (toJSString label)
+             (toJSString language)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLMediaElement.addTextTrack Mozilla HTMLMediaElement.addTextTrack documentation> 
 addTextTrackUnchecked ::
                       (MonadIO m, IsHTMLMediaElement self, ToJSString kind,
                        ToJSString label, ToJSString language) =>
@@ -258,6 +291,16 @@
       (void (js_getVideoPlaybackQuality (toHTMLMediaElement self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLMediaElement.getVideoPlaybackQuality Mozilla HTMLMediaElement.getVideoPlaybackQuality documentation> 
+getVideoPlaybackQualityUnsafe ::
+                              (MonadIO m, IsHTMLMediaElement self, HasCallStack) =>
+                                self -> m VideoPlaybackQuality
+getVideoPlaybackQualityUnsafe self
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_getVideoPlaybackQuality (toHTMLMediaElement self)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLMediaElement.getVideoPlaybackQuality Mozilla HTMLMediaElement.getVideoPlaybackQuality documentation> 
 getVideoPlaybackQualityUnchecked ::
                                  (MonadIO m, IsHTMLMediaElement self) =>
                                    self -> m VideoPlaybackQuality
@@ -298,6 +341,15 @@
       (nullableToMaybe <$> (js_getError (toHTMLMediaElement self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLMediaElement.error Mozilla HTMLMediaElement.error documentation> 
+getErrorUnsafe ::
+               (MonadIO m, IsHTMLMediaElement self, HasCallStack) =>
+                 self -> m MediaError
+getErrorUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getError (toHTMLMediaElement self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLMediaElement.error Mozilla HTMLMediaElement.error documentation> 
 getErrorUnchecked ::
                   (MonadIO m, IsHTMLMediaElement self) => self -> m MediaError
 getErrorUnchecked self
@@ -378,6 +430,15 @@
       (nullableToMaybe <$> (js_getBuffered (toHTMLMediaElement self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLMediaElement.buffered Mozilla HTMLMediaElement.buffered documentation> 
+getBufferedUnsafe ::
+                  (MonadIO m, IsHTMLMediaElement self, HasCallStack) =>
+                    self -> m TimeRanges
+getBufferedUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getBuffered (toHTMLMediaElement self)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLMediaElement.buffered Mozilla HTMLMediaElement.buffered documentation> 
 getBufferedUnchecked ::
                      (MonadIO m, IsHTMLMediaElement self) => self -> m TimeRanges
 getBufferedUnchecked self
@@ -485,6 +546,15 @@
       (nullableToMaybe <$> (js_getPlayed (toHTMLMediaElement self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLMediaElement.played Mozilla HTMLMediaElement.played documentation> 
+getPlayedUnsafe ::
+                (MonadIO m, IsHTMLMediaElement self, HasCallStack) =>
+                  self -> m TimeRanges
+getPlayedUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getPlayed (toHTMLMediaElement self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLMediaElement.played Mozilla HTMLMediaElement.played documentation> 
 getPlayedUnchecked ::
                    (MonadIO m, IsHTMLMediaElement self) => self -> m TimeRanges
 getPlayedUnchecked self
@@ -504,6 +574,15 @@
       (nullableToMaybe <$> (js_getSeekable (toHTMLMediaElement self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLMediaElement.seekable Mozilla HTMLMediaElement.seekable documentation> 
+getSeekableUnsafe ::
+                  (MonadIO m, IsHTMLMediaElement self, HasCallStack) =>
+                    self -> m TimeRanges
+getSeekableUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getSeekable (toHTMLMediaElement self)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLMediaElement.seekable Mozilla HTMLMediaElement.seekable documentation> 
 getSeekableUnchecked ::
                      (MonadIO m, IsHTMLMediaElement self) => self -> m TimeRanges
 getSeekableUnchecked self
@@ -815,6 +894,15 @@
       (nullableToMaybe <$> (js_getWebkitKeys (toHTMLMediaElement self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLMediaElement.webkitKeys Mozilla HTMLMediaElement.webkitKeys documentation> 
+getWebkitKeysUnsafe ::
+                    (MonadIO m, IsHTMLMediaElement self, HasCallStack) =>
+                      self -> m MediaKeys
+getWebkitKeysUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getWebkitKeys (toHTMLMediaElement self)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLMediaElement.webkitKeys Mozilla HTMLMediaElement.webkitKeys documentation> 
 getWebkitKeysUnchecked ::
                        (MonadIO m, IsHTMLMediaElement self) => self -> m MediaKeys
 getWebkitKeysUnchecked self
@@ -835,6 +923,16 @@
       (nullableToMaybe <$> (js_getAudioTracks (toHTMLMediaElement self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLMediaElement.audioTracks Mozilla HTMLMediaElement.audioTracks documentation> 
+getAudioTracksUnsafe ::
+                     (MonadIO m, IsHTMLMediaElement self, HasCallStack) =>
+                       self -> m AudioTrackList
+getAudioTracksUnsafe self
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_getAudioTracks (toHTMLMediaElement self)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLMediaElement.audioTracks Mozilla HTMLMediaElement.audioTracks documentation> 
 getAudioTracksUnchecked ::
                         (MonadIO m, IsHTMLMediaElement self) => self -> m AudioTrackList
 getAudioTracksUnchecked self
@@ -854,6 +952,15 @@
       (nullableToMaybe <$> (js_getTextTracks (toHTMLMediaElement self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLMediaElement.textTracks Mozilla HTMLMediaElement.textTracks documentation> 
+getTextTracksUnsafe ::
+                    (MonadIO m, IsHTMLMediaElement self, HasCallStack) =>
+                      self -> m TextTrackList
+getTextTracksUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getTextTracks (toHTMLMediaElement self)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLMediaElement.textTracks Mozilla HTMLMediaElement.textTracks documentation> 
 getTextTracksUnchecked ::
                        (MonadIO m, IsHTMLMediaElement self) => self -> m TextTrackList
 getTextTracksUnchecked self
@@ -874,6 +981,16 @@
       (nullableToMaybe <$> (js_getVideoTracks (toHTMLMediaElement self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLMediaElement.videoTracks Mozilla HTMLMediaElement.videoTracks documentation> 
+getVideoTracksUnsafe ::
+                     (MonadIO m, IsHTMLMediaElement self, HasCallStack) =>
+                       self -> m VideoTrackList
+getVideoTracksUnsafe self
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_getVideoTracks (toHTMLMediaElement self)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLMediaElement.videoTracks Mozilla HTMLMediaElement.videoTracks documentation> 
 getVideoTracksUnchecked ::
                         (MonadIO m, IsHTMLMediaElement self) => self -> m VideoTrackList
 getVideoTracksUnchecked self
@@ -905,6 +1022,17 @@
          (js_getMediaGroup (toHTMLMediaElement self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLMediaElement.mediaGroup Mozilla HTMLMediaElement.mediaGroup documentation> 
+getMediaGroupUnsafe ::
+                    (MonadIO m, IsHTMLMediaElement self, HasCallStack,
+                     FromJSString result) =>
+                      self -> m result
+getMediaGroupUnsafe self
+  = liftIO
+      ((fromMaybeJSString <$>
+          (js_getMediaGroup (toHTMLMediaElement self)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLMediaElement.mediaGroup Mozilla HTMLMediaElement.mediaGroup documentation> 
 getMediaGroupUnchecked ::
                        (MonadIO m, IsHTMLMediaElement self, FromJSString result) =>
                          self -> m result
@@ -938,6 +1066,15 @@
       (nullableToMaybe <$> (js_getController (toHTMLMediaElement self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLMediaElement.controller Mozilla HTMLMediaElement.controller documentation> 
+getControllerUnsafe ::
+                    (MonadIO m, IsHTMLMediaElement self, HasCallStack) =>
+                      self -> m MediaController
+getControllerUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getController (toHTMLMediaElement self)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLMediaElement.controller Mozilla HTMLMediaElement.controller documentation> 
 getControllerUnchecked ::
                        (MonadIO m, IsHTMLMediaElement self) => self -> m MediaController
 getControllerUnchecked self
@@ -997,6 +1134,16 @@
   = liftIO
       ((js_getSrcObject (toHTMLMediaElement self)) >>=
          fromJSValUnchecked)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLMediaElement.srcObject Mozilla HTMLMediaElement.srcObject documentation> 
+getSrcObjectUnsafe ::
+                   (MonadIO m, IsHTMLMediaElement self, HasCallStack) =>
+                     self -> m MediaStream
+getSrcObjectUnsafe self
+  = liftIO
+      (((js_getSrcObject (toHTMLMediaElement self)) >>=
+          fromJSValUnchecked)
+         >>= maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLMediaElement.srcObject Mozilla HTMLMediaElement.srcObject documentation> 
 getSrcObjectUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/HTMLMenuElement.hs b/src/GHCJS/DOM/JSFFI/Generated/HTMLMenuElement.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/HTMLMenuElement.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/HTMLMenuElement.hs
@@ -1,9 +1,15 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.HTMLMenuElement
        (js_setCompact, setCompact, js_getCompact, getCompact,
-        HTMLMenuElement, castToHTMLMenuElement, gTypeHTMLMenuElement)
+        HTMLMenuElement(..), gTypeHTMLMenuElement)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -19,6 +25,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"compact\"] = $2;"
         js_setCompact :: HTMLMenuElement -> Bool -> IO ()
diff --git a/src/GHCJS/DOM/JSFFI/Generated/HTMLMetaElement.hs b/src/GHCJS/DOM/JSFFI/Generated/HTMLMetaElement.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/HTMLMetaElement.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/HTMLMetaElement.hs
@@ -1,12 +1,17 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.HTMLMetaElement
        (js_setContent, setContent, js_getContent, getContent,
         js_setHttpEquiv, setHttpEquiv, js_getHttpEquiv, getHttpEquiv,
         js_setName, setName, js_getName, getName, js_setScheme, setScheme,
-        js_getScheme, getScheme, HTMLMetaElement, castToHTMLMetaElement,
-        gTypeHTMLMetaElement)
+        js_getScheme, getScheme, HTMLMetaElement(..), gTypeHTMLMetaElement)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -22,6 +27,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"content\"] = $2;"
         js_setContent :: HTMLMetaElement -> JSString -> IO ()
diff --git a/src/GHCJS/DOM/JSFFI/Generated/HTMLMeterElement.hs b/src/GHCJS/DOM/JSFFI/Generated/HTMLMeterElement.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/HTMLMeterElement.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/HTMLMeterElement.hs
@@ -1,13 +1,19 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.HTMLMeterElement
        (js_setValue, setValue, js_getValue, getValue, js_setMin, setMin,
         js_getMin, getMin, js_setMax, setMax, js_getMax, getMax, js_setLow,
         setLow, js_getLow, getLow, js_setHigh, setHigh, js_getHigh,
         getHigh, js_setOptimum, setOptimum, js_getOptimum, getOptimum,
-        js_getLabels, getLabels, getLabelsUnchecked, HTMLMeterElement,
-        castToHTMLMeterElement, gTypeHTMLMeterElement)
+        js_getLabels, getLabels, getLabelsUnsafe, getLabelsUnchecked,
+        HTMLMeterElement(..), gTypeHTMLMeterElement)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -23,6 +29,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"value\"] = $2;" js_setValue
         :: HTMLMeterElement -> Double -> IO ()
@@ -114,6 +130,14 @@
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLMeterElement.labels Mozilla HTMLMeterElement.labels documentation> 
 getLabels :: (MonadIO m) => HTMLMeterElement -> m (Maybe NodeList)
 getLabels self = liftIO (nullableToMaybe <$> (js_getLabels (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLMeterElement.labels Mozilla HTMLMeterElement.labels documentation> 
+getLabelsUnsafe ::
+                (MonadIO m, HasCallStack) => HTMLMeterElement -> m NodeList
+getLabelsUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getLabels (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLMeterElement.labels Mozilla HTMLMeterElement.labels documentation> 
 getLabelsUnchecked :: (MonadIO m) => HTMLMeterElement -> m NodeList
diff --git a/src/GHCJS/DOM/JSFFI/Generated/HTMLModElement.hs b/src/GHCJS/DOM/JSFFI/Generated/HTMLModElement.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/HTMLModElement.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/HTMLModElement.hs
@@ -1,10 +1,16 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.HTMLModElement
        (js_setCite, setCite, js_getCite, getCite, js_setDateTime,
-        setDateTime, js_getDateTime, getDateTime, HTMLModElement,
-        castToHTMLModElement, gTypeHTMLModElement)
+        setDateTime, js_getDateTime, getDateTime, HTMLModElement(..),
+        gTypeHTMLModElement)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -20,6 +26,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"cite\"] = $2;" js_setCite ::
         HTMLModElement -> JSString -> IO ()
diff --git a/src/GHCJS/DOM/JSFFI/Generated/HTMLOListElement.hs b/src/GHCJS/DOM/JSFFI/Generated/HTMLOListElement.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/HTMLOListElement.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/HTMLOListElement.hs
@@ -1,12 +1,17 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.HTMLOListElement
        (js_setCompact, setCompact, js_getCompact, getCompact, js_setStart,
         setStart, js_getStart, getStart, js_setReversed, setReversed,
         js_getReversed, getReversed, js_setType, setType, js_getType,
-        getType, HTMLOListElement, castToHTMLOListElement,
-        gTypeHTMLOListElement)
+        getType, HTMLOListElement(..), gTypeHTMLOListElement)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -22,6 +27,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"compact\"] = $2;"
         js_setCompact :: HTMLOListElement -> Bool -> IO ()
diff --git a/src/GHCJS/DOM/JSFFI/Generated/HTMLObjectElement.hs b/src/GHCJS/DOM/JSFFI/Generated/HTMLObjectElement.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/HTMLObjectElement.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/HTMLObjectElement.hs
@@ -1,12 +1,18 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.HTMLObjectElement
        (js_checkValidity, checkValidity, checkValidity_,
         js_setCustomValidity, setCustomValidity, js_getSVGDocument,
-        getSVGDocument, getSVGDocument_, getSVGDocumentUnchecked,
-        js_getForm, getForm, getFormUnchecked, js_setCode, setCode,
-        js_getCode, getCode, js_setAlign, setAlign, js_getAlign, getAlign,
-        js_setArchive, setArchive, js_getArchive, getArchive, js_setBorder,
-        setBorder, js_getBorder, getBorder, js_setCodeBase, setCodeBase,
+        getSVGDocument, getSVGDocument_, getSVGDocumentUnsafe,
+        getSVGDocumentUnchecked, js_getForm, getForm, getFormUnsafe,
+        getFormUnchecked, js_setCode, setCode, js_getCode, getCode,
+        js_setAlign, setAlign, js_getAlign, getAlign, js_setArchive,
+        setArchive, js_getArchive, getArchive, js_setBorder, setBorder,
+        js_getBorder, getBorder, js_setCodeBase, setCodeBase,
         js_getCodeBase, getCodeBase, js_setCodeType, setCodeType,
         js_getCodeType, getCodeType, js_setData, setData, js_getData,
         getData, js_setDeclare, setDeclare, js_getDeclare, getDeclare,
@@ -17,12 +23,14 @@
         setUseMap, js_getUseMap, getUseMap, js_setVspace, setVspace,
         js_getVspace, getVspace, js_setWidth, setWidth, js_getWidth,
         getWidth, js_getWillValidate, getWillValidate, js_getValidity,
-        getValidity, getValidityUnchecked, js_getValidationMessage,
-        getValidationMessage, js_getContentDocument, getContentDocument,
-        getContentDocumentUnchecked, HTMLObjectElement,
-        castToHTMLObjectElement, gTypeHTMLObjectElement)
+        getValidity, getValidityUnsafe, getValidityUnchecked,
+        js_getValidationMessage, getValidationMessage,
+        js_getContentDocument, getContentDocument,
+        getContentDocumentUnsafe, getContentDocumentUnchecked,
+        HTMLObjectElement(..), gTypeHTMLObjectElement)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -38,6 +46,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe
         "($1[\"checkValidity\"]() ? 1 : 0)" js_checkValidity ::
@@ -76,6 +94,14 @@
 getSVGDocument_ self = liftIO (void (js_getSVGDocument (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLObjectElement.getSVGDocument Mozilla HTMLObjectElement.getSVGDocument documentation> 
+getSVGDocumentUnsafe ::
+                     (MonadIO m, HasCallStack) => HTMLObjectElement -> m SVGDocument
+getSVGDocumentUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getSVGDocument (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLObjectElement.getSVGDocument Mozilla HTMLObjectElement.getSVGDocument documentation> 
 getSVGDocumentUnchecked ::
                         (MonadIO m) => HTMLObjectElement -> m SVGDocument
 getSVGDocumentUnchecked self
@@ -91,6 +117,14 @@
 getForm self = liftIO (nullableToMaybe <$> (js_getForm (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLObjectElement.form Mozilla HTMLObjectElement.form documentation> 
+getFormUnsafe ::
+              (MonadIO m, HasCallStack) => HTMLObjectElement -> m HTMLFormElement
+getFormUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getForm (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLObjectElement.form Mozilla HTMLObjectElement.form documentation> 
 getFormUnchecked ::
                  (MonadIO m) => HTMLObjectElement -> m HTMLFormElement
 getFormUnchecked self
@@ -369,6 +403,14 @@
   = liftIO (nullableToMaybe <$> (js_getValidity (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLObjectElement.validity Mozilla HTMLObjectElement.validity documentation> 
+getValidityUnsafe ::
+                  (MonadIO m, HasCallStack) => HTMLObjectElement -> m ValidityState
+getValidityUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getValidity (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLObjectElement.validity Mozilla HTMLObjectElement.validity documentation> 
 getValidityUnchecked ::
                      (MonadIO m) => HTMLObjectElement -> m ValidityState
 getValidityUnchecked self
@@ -392,6 +434,14 @@
                    (MonadIO m) => HTMLObjectElement -> m (Maybe Document)
 getContentDocument self
   = liftIO (nullableToMaybe <$> (js_getContentDocument (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLObjectElement.contentDocument Mozilla HTMLObjectElement.contentDocument documentation> 
+getContentDocumentUnsafe ::
+                         (MonadIO m, HasCallStack) => HTMLObjectElement -> m Document
+getContentDocumentUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getContentDocument (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLObjectElement.contentDocument Mozilla HTMLObjectElement.contentDocument documentation> 
 getContentDocumentUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/HTMLOptGroupElement.hs b/src/GHCJS/DOM/JSFFI/Generated/HTMLOptGroupElement.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/HTMLOptGroupElement.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/HTMLOptGroupElement.hs
@@ -1,10 +1,16 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.HTMLOptGroupElement
        (js_setDisabled, setDisabled, js_getDisabled, getDisabled,
-        js_setLabel, setLabel, js_getLabel, getLabel, HTMLOptGroupElement,
-        castToHTMLOptGroupElement, gTypeHTMLOptGroupElement)
+        js_setLabel, setLabel, js_getLabel, getLabel,
+        HTMLOptGroupElement(..), gTypeHTMLOptGroupElement)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -20,6 +26,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"disabled\"] = $2;"
         js_setDisabled :: HTMLOptGroupElement -> Bool -> IO ()
diff --git a/src/GHCJS/DOM/JSFFI/Generated/HTMLOptionElement.hs b/src/GHCJS/DOM/JSFFI/Generated/HTMLOptionElement.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/HTMLOptionElement.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/HTMLOptionElement.hs
@@ -1,15 +1,21 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.HTMLOptionElement
        (js_setDisabled, setDisabled, js_getDisabled, getDisabled,
-        js_getForm, getForm, getFormUnchecked, js_setLabel, setLabel,
-        js_getLabel, getLabel, js_setDefaultSelected, setDefaultSelected,
-        js_getDefaultSelected, getDefaultSelected, js_setSelected,
-        setSelected, js_getSelected, getSelected, js_setValue, setValue,
-        js_getValue, getValue, js_setText, setText, js_getText, getText,
-        js_getIndex, getIndex, HTMLOptionElement, castToHTMLOptionElement,
+        js_getForm, getForm, getFormUnsafe, getFormUnchecked, js_setLabel,
+        setLabel, js_getLabel, getLabel, js_setDefaultSelected,
+        setDefaultSelected, js_getDefaultSelected, getDefaultSelected,
+        js_setSelected, setSelected, js_getSelected, getSelected,
+        js_setValue, setValue, js_getValue, getValue, js_setText, setText,
+        js_getText, getText, js_getIndex, getIndex, HTMLOptionElement(..),
         gTypeHTMLOptionElement)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -25,6 +31,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"disabled\"] = $2;"
         js_setDisabled :: HTMLOptionElement -> Bool -> IO ()
@@ -47,6 +63,14 @@
 getForm ::
         (MonadIO m) => HTMLOptionElement -> m (Maybe HTMLFormElement)
 getForm self = liftIO (nullableToMaybe <$> (js_getForm (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLOptionElement.form Mozilla HTMLOptionElement.form documentation> 
+getFormUnsafe ::
+              (MonadIO m, HasCallStack) => HTMLOptionElement -> m HTMLFormElement
+getFormUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getForm (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLOptionElement.form Mozilla HTMLOptionElement.form documentation> 
 getFormUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/HTMLOptionsCollection.hs b/src/GHCJS/DOM/JSFFI/Generated/HTMLOptionsCollection.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/HTMLOptionsCollection.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/HTMLOptionsCollection.hs
@@ -1,13 +1,19 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.HTMLOptionsCollection
-       (js_namedItem, namedItem, namedItem_, namedItemUnchecked,
-        js_addBefore, addBefore, js_add, add, js_remove, remove,
-        js_setSelectedIndex, setSelectedIndex, js_getSelectedIndex,
-        getSelectedIndex, js_setLength, setLength, js_getLength, getLength,
-        HTMLOptionsCollection, castToHTMLOptionsCollection,
+       (js_namedItem, namedItem, namedItem_, namedItemUnsafe,
+        namedItemUnchecked, js_addBefore, addBefore, js_add, add,
+        js_remove, remove, js_setSelectedIndex, setSelectedIndex,
+        js_getSelectedIndex, getSelectedIndex, js_setLength, setLength,
+        js_getLength, getLength, HTMLOptionsCollection(..),
         gTypeHTMLOptionsCollection)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -23,6 +29,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"namedItem\"]($2)"
         js_namedItem ::
@@ -42,6 +58,15 @@
              HTMLOptionsCollection -> name -> m ()
 namedItem_ self name
   = liftIO (void (js_namedItem (self) (toJSString name)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLOptionsCollection.namedItem Mozilla HTMLOptionsCollection.namedItem documentation> 
+namedItemUnsafe ::
+                (MonadIO m, ToJSString name, HasCallStack) =>
+                  HTMLOptionsCollection -> name -> m Node
+namedItemUnsafe self name
+  = liftIO
+      ((nullableToMaybe <$> (js_namedItem (self) (toJSString name))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLOptionsCollection.namedItem Mozilla HTMLOptionsCollection.namedItem documentation> 
 namedItemUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/HTMLOutputElement.hs b/src/GHCJS/DOM/JSFFI/Generated/HTMLOutputElement.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/HTMLOutputElement.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/HTMLOutputElement.hs
@@ -1,18 +1,25 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.HTMLOutputElement
        (js_checkValidity, checkValidity, checkValidity_,
         js_setCustomValidity, setCustomValidity, js_getHtmlFor, getHtmlFor,
-        getHtmlForUnchecked, js_getForm, getForm, getFormUnchecked,
-        js_setName, setName, js_getName, getName, js_getType, getType,
-        js_setDefaultValue, setDefaultValue, js_getDefaultValue,
-        getDefaultValue, getDefaultValueUnchecked, js_setValue, setValue,
-        js_getValue, getValue, getValueUnchecked, js_getWillValidate,
-        getWillValidate, js_getValidity, getValidity, getValidityUnchecked,
-        js_getValidationMessage, getValidationMessage, js_getLabels,
-        getLabels, getLabelsUnchecked, HTMLOutputElement,
-        castToHTMLOutputElement, gTypeHTMLOutputElement)
+        getHtmlForUnsafe, getHtmlForUnchecked, js_getForm, getForm,
+        getFormUnsafe, getFormUnchecked, js_setName, setName, js_getName,
+        getName, js_getType, getType, js_setDefaultValue, setDefaultValue,
+        js_getDefaultValue, getDefaultValue, getDefaultValueUnsafe,
+        getDefaultValueUnchecked, js_setValue, setValue, js_getValue,
+        getValue, getValueUnsafe, getValueUnchecked, js_getWillValidate,
+        getWillValidate, js_getValidity, getValidity, getValidityUnsafe,
+        getValidityUnchecked, js_getValidationMessage,
+        getValidationMessage, js_getLabels, getLabels, getLabelsUnsafe,
+        getLabelsUnchecked, HTMLOutputElement(..), gTypeHTMLOutputElement)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -28,6 +35,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe
         "($1[\"checkValidity\"]() ? 1 : 0)" js_checkValidity ::
@@ -62,6 +79,15 @@
   = liftIO (nullableToMaybe <$> (js_getHtmlFor (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLOutputElement.htmlFor Mozilla HTMLOutputElement.htmlFor documentation> 
+getHtmlForUnsafe ::
+                 (MonadIO m, HasCallStack) =>
+                   HTMLOutputElement -> m DOMSettableTokenList
+getHtmlForUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getHtmlFor (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLOutputElement.htmlFor Mozilla HTMLOutputElement.htmlFor documentation> 
 getHtmlForUnchecked ::
                     (MonadIO m) => HTMLOutputElement -> m DOMSettableTokenList
 getHtmlForUnchecked self
@@ -76,6 +102,14 @@
 getForm self = liftIO (nullableToMaybe <$> (js_getForm (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLOutputElement.form Mozilla HTMLOutputElement.form documentation> 
+getFormUnsafe ::
+              (MonadIO m, HasCallStack) => HTMLOutputElement -> m HTMLFormElement
+getFormUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getForm (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLOutputElement.form Mozilla HTMLOutputElement.form documentation> 
 getFormUnchecked ::
                  (MonadIO m) => HTMLOutputElement -> m HTMLFormElement
 getFormUnchecked self
@@ -127,6 +161,15 @@
   = liftIO (fromMaybeJSString <$> (js_getDefaultValue (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLOutputElement.defaultValue Mozilla HTMLOutputElement.defaultValue documentation> 
+getDefaultValueUnsafe ::
+                      (MonadIO m, HasCallStack, FromJSString result) =>
+                        HTMLOutputElement -> m result
+getDefaultValueUnsafe self
+  = liftIO
+      ((fromMaybeJSString <$> (js_getDefaultValue (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLOutputElement.defaultValue Mozilla HTMLOutputElement.defaultValue documentation> 
 getDefaultValueUnchecked ::
                          (MonadIO m, FromJSString result) => HTMLOutputElement -> m result
 getDefaultValueUnchecked self
@@ -153,6 +196,15 @@
 getValue self = liftIO (fromMaybeJSString <$> (js_getValue (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLOutputElement.value Mozilla HTMLOutputElement.value documentation> 
+getValueUnsafe ::
+               (MonadIO m, HasCallStack, FromJSString result) =>
+                 HTMLOutputElement -> m result
+getValueUnsafe self
+  = liftIO
+      ((fromMaybeJSString <$> (js_getValue (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLOutputElement.value Mozilla HTMLOutputElement.value documentation> 
 getValueUnchecked ::
                   (MonadIO m, FromJSString result) => HTMLOutputElement -> m result
 getValueUnchecked self
@@ -175,6 +227,14 @@
   = liftIO (nullableToMaybe <$> (js_getValidity (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLOutputElement.validity Mozilla HTMLOutputElement.validity documentation> 
+getValidityUnsafe ::
+                  (MonadIO m, HasCallStack) => HTMLOutputElement -> m ValidityState
+getValidityUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getValidity (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLOutputElement.validity Mozilla HTMLOutputElement.validity documentation> 
 getValidityUnchecked ::
                      (MonadIO m) => HTMLOutputElement -> m ValidityState
 getValidityUnchecked self
@@ -195,6 +255,14 @@
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLOutputElement.labels Mozilla HTMLOutputElement.labels documentation> 
 getLabels :: (MonadIO m) => HTMLOutputElement -> m (Maybe NodeList)
 getLabels self = liftIO (nullableToMaybe <$> (js_getLabels (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLOutputElement.labels Mozilla HTMLOutputElement.labels documentation> 
+getLabelsUnsafe ::
+                (MonadIO m, HasCallStack) => HTMLOutputElement -> m NodeList
+getLabelsUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getLabels (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLOutputElement.labels Mozilla HTMLOutputElement.labels documentation> 
 getLabelsUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/HTMLParagraphElement.hs b/src/GHCJS/DOM/JSFFI/Generated/HTMLParagraphElement.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/HTMLParagraphElement.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/HTMLParagraphElement.hs
@@ -1,10 +1,15 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.HTMLParagraphElement
        (js_setAlign, setAlign, js_getAlign, getAlign,
-        HTMLParagraphElement, castToHTMLParagraphElement,
-        gTypeHTMLParagraphElement)
+        HTMLParagraphElement(..), gTypeHTMLParagraphElement)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -20,6 +25,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"align\"] = $2;" js_setAlign
         :: HTMLParagraphElement -> JSString -> IO ()
diff --git a/src/GHCJS/DOM/JSFFI/Generated/HTMLParamElement.hs b/src/GHCJS/DOM/JSFFI/Generated/HTMLParamElement.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/HTMLParamElement.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/HTMLParamElement.hs
@@ -1,11 +1,17 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.HTMLParamElement
        (js_setName, setName, js_getName, getName, js_setType, setType,
         js_getType, getType, js_setValue, setValue, js_getValue, getValue,
         js_setValueType, setValueType, js_getValueType, getValueType,
-        HTMLParamElement, castToHTMLParamElement, gTypeHTMLParamElement)
+        HTMLParamElement(..), gTypeHTMLParamElement)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -21,6 +27,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"name\"] = $2;" js_setName ::
         HTMLParamElement -> JSString -> IO ()
diff --git a/src/GHCJS/DOM/JSFFI/Generated/HTMLPreElement.hs b/src/GHCJS/DOM/JSFFI/Generated/HTMLPreElement.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/HTMLPreElement.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/HTMLPreElement.hs
@@ -1,10 +1,15 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.HTMLPreElement
        (js_setWidth, setWidth, js_getWidth, getWidth, js_setWrap, setWrap,
-        js_getWrap, getWrap, HTMLPreElement, castToHTMLPreElement,
-        gTypeHTMLPreElement)
+        js_getWrap, getWrap, HTMLPreElement(..), gTypeHTMLPreElement)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -20,6 +25,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"width\"] = $2;" js_setWidth
         :: HTMLPreElement -> Int -> IO ()
diff --git a/src/GHCJS/DOM/JSFFI/Generated/HTMLProgressElement.hs b/src/GHCJS/DOM/JSFFI/Generated/HTMLProgressElement.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/HTMLProgressElement.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/HTMLProgressElement.hs
@@ -1,11 +1,17 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.HTMLProgressElement
        (js_setValue, setValue, js_getValue, getValue, js_setMax, setMax,
         js_getMax, getMax, js_getPosition, getPosition, js_getLabels,
-        getLabels, getLabelsUnchecked, HTMLProgressElement,
-        castToHTMLProgressElement, gTypeHTMLProgressElement)
+        getLabels, getLabelsUnsafe, getLabelsUnchecked,
+        HTMLProgressElement(..), gTypeHTMLProgressElement)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -21,6 +27,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"value\"] = $2;" js_setValue
         :: HTMLProgressElement -> Double -> IO ()
@@ -64,6 +80,14 @@
 getLabels ::
           (MonadIO m) => HTMLProgressElement -> m (Maybe NodeList)
 getLabels self = liftIO (nullableToMaybe <$> (js_getLabels (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLProgressElement.labels Mozilla HTMLProgressElement.labels documentation> 
+getLabelsUnsafe ::
+                (MonadIO m, HasCallStack) => HTMLProgressElement -> m NodeList
+getLabelsUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getLabels (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLProgressElement.labels Mozilla HTMLProgressElement.labels documentation> 
 getLabelsUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/HTMLQuoteElement.hs b/src/GHCJS/DOM/JSFFI/Generated/HTMLQuoteElement.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/HTMLQuoteElement.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/HTMLQuoteElement.hs
@@ -1,9 +1,15 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.HTMLQuoteElement
-       (js_setCite, setCite, js_getCite, getCite, HTMLQuoteElement,
-        castToHTMLQuoteElement, gTypeHTMLQuoteElement)
+       (js_setCite, setCite, js_getCite, getCite, HTMLQuoteElement(..),
+        gTypeHTMLQuoteElement)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -19,6 +25,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"cite\"] = $2;" js_setCite ::
         HTMLQuoteElement -> JSString -> IO ()
diff --git a/src/GHCJS/DOM/JSFFI/Generated/HTMLScriptElement.hs b/src/GHCJS/DOM/JSFFI/Generated/HTMLScriptElement.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/HTMLScriptElement.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/HTMLScriptElement.hs
@@ -1,16 +1,23 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.HTMLScriptElement
-       (js_setText, setText, js_getText, getText, getTextUnchecked,
-        js_setHtmlFor, setHtmlFor, js_getHtmlFor, getHtmlFor, js_setEvent,
-        setEvent, js_getEvent, getEvent, js_setCharset, setCharset,
-        js_getCharset, getCharset, js_setAsync, setAsync, js_getAsync,
-        getAsync, js_setDefer, setDefer, js_getDefer, getDefer, js_setSrc,
-        setSrc, js_getSrc, getSrc, js_setType, setType, js_getType,
-        getType, js_setCrossOrigin, setCrossOrigin, js_getCrossOrigin,
-        getCrossOrigin, js_setNonce, setNonce, js_getNonce, getNonce,
-        HTMLScriptElement, castToHTMLScriptElement, gTypeHTMLScriptElement)
+       (js_setText, setText, js_getText, getText, getTextUnsafe,
+        getTextUnchecked, js_setHtmlFor, setHtmlFor, js_getHtmlFor,
+        getHtmlFor, js_setEvent, setEvent, js_getEvent, getEvent,
+        js_setCharset, setCharset, js_getCharset, getCharset, js_setAsync,
+        setAsync, js_getAsync, getAsync, js_setDefer, setDefer,
+        js_getDefer, getDefer, js_setSrc, setSrc, js_getSrc, getSrc,
+        js_setType, setType, js_getType, getType, js_setCrossOrigin,
+        setCrossOrigin, js_getCrossOrigin, getCrossOrigin, js_setNonce,
+        setNonce, js_getNonce, getNonce, HTMLScriptElement(..),
+        gTypeHTMLScriptElement)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -26,6 +33,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"text\"] = $2;" js_setText ::
         HTMLScriptElement -> Nullable JSString -> IO ()
@@ -44,6 +61,15 @@
         (MonadIO m, FromJSString result) =>
           HTMLScriptElement -> m (Maybe result)
 getText self = liftIO (fromMaybeJSString <$> (js_getText (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLScriptElement.text Mozilla HTMLScriptElement.text documentation> 
+getTextUnsafe ::
+              (MonadIO m, HasCallStack, FromJSString result) =>
+                HTMLScriptElement -> m result
+getTextUnsafe self
+  = liftIO
+      ((fromMaybeJSString <$> (js_getText (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLScriptElement.text Mozilla HTMLScriptElement.text documentation> 
 getTextUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/HTMLSelectElement.hs b/src/GHCJS/DOM/JSFFI/Generated/HTMLSelectElement.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/HTMLSelectElement.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/HTMLSelectElement.hs
@@ -1,27 +1,35 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.HTMLSelectElement
-       (js_item, item, item_, itemUnchecked, js_namedItem, namedItem,
-        namedItem_, namedItemUnchecked, js_addBefore, addBefore, js_add,
-        add, js_remove, remove, js_checkValidity, checkValidity,
-        checkValidity_, js_setCustomValidity, setCustomValidity,
-        js_setAutofocus, setAutofocus, js_getAutofocus, getAutofocus,
-        js_setDisabled, setDisabled, js_getDisabled, getDisabled,
-        js_getForm, getForm, getFormUnchecked, js_setMultiple, setMultiple,
+       (js_item, item, item_, itemUnsafe, itemUnchecked, js_namedItem,
+        namedItem, namedItem_, namedItemUnsafe, namedItemUnchecked,
+        js_addBefore, addBefore, js_add, add, js_remove, remove,
+        js_checkValidity, checkValidity, checkValidity_,
+        js_setCustomValidity, setCustomValidity, js_setAutofocus,
+        setAutofocus, js_getAutofocus, getAutofocus, js_setDisabled,
+        setDisabled, js_getDisabled, getDisabled, js_getForm, getForm,
+        getFormUnsafe, getFormUnchecked, js_setMultiple, setMultiple,
         js_getMultiple, getMultiple, js_setName, setName, js_getName,
         getName, js_setRequired, setRequired, js_getRequired, getRequired,
         js_setSize, setSize, js_getSize, getSize, js_getType, getType,
-        js_getOptions, getOptions, getOptionsUnchecked, js_setLength,
-        setLength, js_getLength, getLength, js_getSelectedOptions,
-        getSelectedOptions, getSelectedOptionsUnchecked,
+        js_getOptions, getOptions, getOptionsUnsafe, getOptionsUnchecked,
+        js_setLength, setLength, js_getLength, getLength,
+        js_getSelectedOptions, getSelectedOptions,
+        getSelectedOptionsUnsafe, getSelectedOptionsUnchecked,
         js_setSelectedIndex, setSelectedIndex, js_getSelectedIndex,
         getSelectedIndex, js_setValue, setValue, js_getValue, getValue,
-        getValueUnchecked, js_getWillValidate, getWillValidate,
-        js_getValidity, getValidity, getValidityUnchecked,
-        js_getValidationMessage, getValidationMessage, js_getLabels,
-        getLabels, getLabelsUnchecked, HTMLSelectElement,
-        castToHTMLSelectElement, gTypeHTMLSelectElement)
+        getValueUnsafe, getValueUnchecked, js_getWillValidate,
+        getWillValidate, js_getValidity, getValidity, getValidityUnsafe,
+        getValidityUnchecked, js_getValidationMessage,
+        getValidationMessage, js_getLabels, getLabels, getLabelsUnsafe,
+        getLabelsUnchecked, HTMLSelectElement(..), gTypeHTMLSelectElement)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -37,6 +45,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"item\"]($2)" js_item ::
         HTMLSelectElement -> Word -> IO (Nullable Node)
@@ -51,6 +69,14 @@
 item_ self index = liftIO (void (js_item (self) index))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLSelectElement.item Mozilla HTMLSelectElement.item documentation> 
+itemUnsafe ::
+           (MonadIO m, HasCallStack) => HTMLSelectElement -> Word -> m Node
+itemUnsafe self index
+  = liftIO
+      ((nullableToMaybe <$> (js_item (self) index)) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLSelectElement.item Mozilla HTMLSelectElement.item documentation> 
 itemUnchecked :: (MonadIO m) => HTMLSelectElement -> Word -> m Node
 itemUnchecked self index
   = liftIO (fromJust . nullableToMaybe <$> (js_item (self) index))
@@ -73,6 +99,15 @@
   = liftIO (void (js_namedItem (self) (toJSString name)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLSelectElement.namedItem Mozilla HTMLSelectElement.namedItem documentation> 
+namedItemUnsafe ::
+                (MonadIO m, ToJSString name, HasCallStack) =>
+                  HTMLSelectElement -> name -> m Node
+namedItemUnsafe self name
+  = liftIO
+      ((nullableToMaybe <$> (js_namedItem (self) (toJSString name))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLSelectElement.namedItem Mozilla HTMLSelectElement.namedItem documentation> 
 namedItemUnchecked ::
                    (MonadIO m, ToJSString name) => HTMLSelectElement -> name -> m Node
 namedItemUnchecked self name
@@ -173,6 +208,14 @@
 getForm self = liftIO (nullableToMaybe <$> (js_getForm (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLSelectElement.form Mozilla HTMLSelectElement.form documentation> 
+getFormUnsafe ::
+              (MonadIO m, HasCallStack) => HTMLSelectElement -> m HTMLFormElement
+getFormUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getForm (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLSelectElement.form Mozilla HTMLSelectElement.form documentation> 
 getFormUnchecked ::
                  (MonadIO m) => HTMLSelectElement -> m HTMLFormElement
 getFormUnchecked self
@@ -254,6 +297,15 @@
   = liftIO (nullableToMaybe <$> (js_getOptions (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLSelectElement.options Mozilla HTMLSelectElement.options documentation> 
+getOptionsUnsafe ::
+                 (MonadIO m, HasCallStack) =>
+                   HTMLSelectElement -> m HTMLOptionsCollection
+getOptionsUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getOptions (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLSelectElement.options Mozilla HTMLSelectElement.options documentation> 
 getOptionsUnchecked ::
                     (MonadIO m) => HTMLSelectElement -> m HTMLOptionsCollection
 getOptionsUnchecked self
@@ -284,6 +336,14 @@
   = liftIO (nullableToMaybe <$> (js_getSelectedOptions (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLSelectElement.selectedOptions Mozilla HTMLSelectElement.selectedOptions documentation> 
+getSelectedOptionsUnsafe ::
+                         (MonadIO m, HasCallStack) => HTMLSelectElement -> m HTMLCollection
+getSelectedOptionsUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getSelectedOptions (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLSelectElement.selectedOptions Mozilla HTMLSelectElement.selectedOptions documentation> 
 getSelectedOptionsUnchecked ::
                             (MonadIO m) => HTMLSelectElement -> m HTMLCollection
 getSelectedOptionsUnchecked self
@@ -324,6 +384,15 @@
 getValue self = liftIO (fromMaybeJSString <$> (js_getValue (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLSelectElement.value Mozilla HTMLSelectElement.value documentation> 
+getValueUnsafe ::
+               (MonadIO m, HasCallStack, FromJSString result) =>
+                 HTMLSelectElement -> m result
+getValueUnsafe self
+  = liftIO
+      ((fromMaybeJSString <$> (js_getValue (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLSelectElement.value Mozilla HTMLSelectElement.value documentation> 
 getValueUnchecked ::
                   (MonadIO m, FromJSString result) => HTMLSelectElement -> m result
 getValueUnchecked self
@@ -346,6 +415,14 @@
   = liftIO (nullableToMaybe <$> (js_getValidity (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLSelectElement.validity Mozilla HTMLSelectElement.validity documentation> 
+getValidityUnsafe ::
+                  (MonadIO m, HasCallStack) => HTMLSelectElement -> m ValidityState
+getValidityUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getValidity (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLSelectElement.validity Mozilla HTMLSelectElement.validity documentation> 
 getValidityUnchecked ::
                      (MonadIO m) => HTMLSelectElement -> m ValidityState
 getValidityUnchecked self
@@ -366,6 +443,14 @@
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLSelectElement.labels Mozilla HTMLSelectElement.labels documentation> 
 getLabels :: (MonadIO m) => HTMLSelectElement -> m (Maybe NodeList)
 getLabels self = liftIO (nullableToMaybe <$> (js_getLabels (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLSelectElement.labels Mozilla HTMLSelectElement.labels documentation> 
+getLabelsUnsafe ::
+                (MonadIO m, HasCallStack) => HTMLSelectElement -> m NodeList
+getLabelsUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getLabels (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLSelectElement.labels Mozilla HTMLSelectElement.labels documentation> 
 getLabelsUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/HTMLSourceElement.hs b/src/GHCJS/DOM/JSFFI/Generated/HTMLSourceElement.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/HTMLSourceElement.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/HTMLSourceElement.hs
@@ -1,10 +1,16 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.HTMLSourceElement
        (js_setSrc, setSrc, js_getSrc, getSrc, js_setType, setType,
         js_getType, getType, js_setMedia, setMedia, js_getMedia, getMedia,
-        HTMLSourceElement, castToHTMLSourceElement, gTypeHTMLSourceElement)
+        HTMLSourceElement(..), gTypeHTMLSourceElement)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -20,6 +26,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"src\"] = $2;" js_setSrc ::
         HTMLSourceElement -> JSString -> IO ()
diff --git a/src/GHCJS/DOM/JSFFI/Generated/HTMLStyleElement.hs b/src/GHCJS/DOM/JSFFI/Generated/HTMLStyleElement.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/HTMLStyleElement.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/HTMLStyleElement.hs
@@ -1,11 +1,17 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.HTMLStyleElement
        (js_setDisabled, setDisabled, js_getDisabled, getDisabled,
         js_setMedia, setMedia, js_getMedia, getMedia, js_setType, setType,
-        js_getType, getType, js_getSheet, getSheet, getSheetUnchecked,
-        HTMLStyleElement, castToHTMLStyleElement, gTypeHTMLStyleElement)
+        js_getType, getType, js_getSheet, getSheet, getSheetUnsafe,
+        getSheetUnchecked, HTMLStyleElement(..), gTypeHTMLStyleElement)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -21,6 +27,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"disabled\"] = $2;"
         js_setDisabled :: HTMLStyleElement -> Bool -> IO ()
@@ -74,6 +90,14 @@
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLStyleElement.sheet Mozilla HTMLStyleElement.sheet documentation> 
 getSheet :: (MonadIO m) => HTMLStyleElement -> m (Maybe StyleSheet)
 getSheet self = liftIO (nullableToMaybe <$> (js_getSheet (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLStyleElement.sheet Mozilla HTMLStyleElement.sheet documentation> 
+getSheetUnsafe ::
+               (MonadIO m, HasCallStack) => HTMLStyleElement -> m StyleSheet
+getSheetUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getSheet (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLStyleElement.sheet Mozilla HTMLStyleElement.sheet documentation> 
 getSheetUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/HTMLTableCaptionElement.hs b/src/GHCJS/DOM/JSFFI/Generated/HTMLTableCaptionElement.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/HTMLTableCaptionElement.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/HTMLTableCaptionElement.hs
@@ -1,10 +1,15 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.HTMLTableCaptionElement
        (js_setAlign, setAlign, js_getAlign, getAlign,
-        HTMLTableCaptionElement, castToHTMLTableCaptionElement,
-        gTypeHTMLTableCaptionElement)
+        HTMLTableCaptionElement(..), gTypeHTMLTableCaptionElement)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -20,6 +25,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"align\"] = $2;" js_setAlign
         :: HTMLTableCaptionElement -> JSString -> IO ()
diff --git a/src/GHCJS/DOM/JSFFI/Generated/HTMLTableCellElement.hs b/src/GHCJS/DOM/JSFFI/Generated/HTMLTableCellElement.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/HTMLTableCellElement.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/HTMLTableCellElement.hs
@@ -1,4 +1,9 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.HTMLTableCellElement
        (js_getCellIndex, getCellIndex, js_setAbbr, setAbbr, js_getAbbr,
         getAbbr, js_setAlign, setAlign, js_getAlign, getAlign, js_setAxis,
@@ -11,10 +16,10 @@
         js_setRowSpan, setRowSpan, js_getRowSpan, getRowSpan, js_setScope,
         setScope, js_getScope, getScope, js_setVAlign, setVAlign,
         js_getVAlign, getVAlign, js_setWidth, setWidth, js_getWidth,
-        getWidth, HTMLTableCellElement, castToHTMLTableCellElement,
-        gTypeHTMLTableCellElement)
+        getWidth, HTMLTableCellElement(..), gTypeHTMLTableCellElement)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -30,6 +35,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"cellIndex\"]"
         js_getCellIndex :: HTMLTableCellElement -> IO Int
diff --git a/src/GHCJS/DOM/JSFFI/Generated/HTMLTableColElement.hs b/src/GHCJS/DOM/JSFFI/Generated/HTMLTableColElement.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/HTMLTableColElement.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/HTMLTableColElement.hs
@@ -1,13 +1,18 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.HTMLTableColElement
        (js_setAlign, setAlign, js_getAlign, getAlign, js_setCh, setCh,
         js_getCh, getCh, js_setChOff, setChOff, js_getChOff, getChOff,
         js_setSpan, setSpan, js_getSpan, getSpan, js_setVAlign, setVAlign,
         js_getVAlign, getVAlign, js_setWidth, setWidth, js_getWidth,
-        getWidth, HTMLTableColElement, castToHTMLTableColElement,
-        gTypeHTMLTableColElement)
+        getWidth, HTMLTableColElement(..), gTypeHTMLTableColElement)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -23,6 +28,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"align\"] = $2;" js_setAlign
         :: HTMLTableColElement -> JSString -> IO ()
diff --git a/src/GHCJS/DOM/JSFFI/Generated/HTMLTableElement.hs b/src/GHCJS/DOM/JSFFI/Generated/HTMLTableElement.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/HTMLTableElement.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/HTMLTableElement.hs
@@ -1,28 +1,37 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.HTMLTableElement
-       (js_createTHead, createTHead, createTHead_, createTHeadUnchecked,
-        js_deleteTHead, deleteTHead, js_createTFoot, createTFoot,
-        createTFoot_, createTFootUnchecked, js_deleteTFoot, deleteTFoot,
-        js_createTBody, createTBody, createTBody_, createTBodyUnchecked,
+       (js_createTHead, createTHead, createTHead_, createTHeadUnsafe,
+        createTHeadUnchecked, js_deleteTHead, deleteTHead, js_createTFoot,
+        createTFoot, createTFoot_, createTFootUnsafe, createTFootUnchecked,
+        js_deleteTFoot, deleteTFoot, js_createTBody, createTBody,
+        createTBody_, createTBodyUnsafe, createTBodyUnchecked,
         js_createCaption, createCaption, createCaption_,
-        createCaptionUnchecked, js_deleteCaption, deleteCaption,
-        js_insertRow, insertRow, insertRow_, insertRowUnchecked,
-        js_deleteRow, deleteRow, js_setCaption, setCaption, js_getCaption,
-        getCaption, getCaptionUnchecked, js_setTHead, setTHead,
-        js_getTHead, getTHead, getTHeadUnchecked, js_setTFoot, setTFoot,
-        js_getTFoot, getTFoot, getTFootUnchecked, js_getRows, getRows,
-        getRowsUnchecked, js_getTBodies, getTBodies, getTBodiesUnchecked,
-        js_setAlign, setAlign, js_getAlign, getAlign, js_setBgColor,
-        setBgColor, js_getBgColor, getBgColor, js_setBorder, setBorder,
-        js_getBorder, getBorder, js_setCellPadding, setCellPadding,
-        js_getCellPadding, getCellPadding, js_setCellSpacing,
-        setCellSpacing, js_getCellSpacing, getCellSpacing, js_setFrame,
-        setFrame, js_getFrame, getFrame, js_setRules, setRules,
-        js_getRules, getRules, js_setSummary, setSummary, js_getSummary,
-        getSummary, js_setWidth, setWidth, js_getWidth, getWidth,
-        HTMLTableElement, castToHTMLTableElement, gTypeHTMLTableElement)
+        createCaptionUnsafe, createCaptionUnchecked, js_deleteCaption,
+        deleteCaption, js_insertRow, insertRow, insertRow_,
+        insertRowUnsafe, insertRowUnchecked, js_deleteRow, deleteRow,
+        js_setCaption, setCaption, js_getCaption, getCaption,
+        getCaptionUnsafe, getCaptionUnchecked, js_setTHead, setTHead,
+        js_getTHead, getTHead, getTHeadUnsafe, getTHeadUnchecked,
+        js_setTFoot, setTFoot, js_getTFoot, getTFoot, getTFootUnsafe,
+        getTFootUnchecked, js_getRows, getRows, getRowsUnsafe,
+        getRowsUnchecked, js_getTBodies, getTBodies, getTBodiesUnsafe,
+        getTBodiesUnchecked, js_setAlign, setAlign, js_getAlign, getAlign,
+        js_setBgColor, setBgColor, js_getBgColor, getBgColor, js_setBorder,
+        setBorder, js_getBorder, getBorder, js_setCellPadding,
+        setCellPadding, js_getCellPadding, getCellPadding,
+        js_setCellSpacing, setCellSpacing, js_getCellSpacing,
+        getCellSpacing, js_setFrame, setFrame, js_getFrame, getFrame,
+        js_setRules, setRules, js_getRules, getRules, js_setSummary,
+        setSummary, js_getSummary, getSummary, js_setWidth, setWidth,
+        js_getWidth, getWidth, HTMLTableElement(..), gTypeHTMLTableElement)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -38,6 +47,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"createTHead\"]()"
         js_createTHead :: HTMLTableElement -> IO (Nullable HTMLElement)
@@ -53,6 +72,14 @@
 createTHead_ self = liftIO (void (js_createTHead (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLTableElement.createTHead Mozilla HTMLTableElement.createTHead documentation> 
+createTHeadUnsafe ::
+                  (MonadIO m, HasCallStack) => HTMLTableElement -> m HTMLElement
+createTHeadUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_createTHead (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLTableElement.createTHead Mozilla HTMLTableElement.createTHead documentation> 
 createTHeadUnchecked ::
                      (MonadIO m) => HTMLTableElement -> m HTMLElement
 createTHeadUnchecked self
@@ -79,6 +106,14 @@
 createTFoot_ self = liftIO (void (js_createTFoot (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLTableElement.createTFoot Mozilla HTMLTableElement.createTFoot documentation> 
+createTFootUnsafe ::
+                  (MonadIO m, HasCallStack) => HTMLTableElement -> m HTMLElement
+createTFootUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_createTFoot (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLTableElement.createTFoot Mozilla HTMLTableElement.createTFoot documentation> 
 createTFootUnchecked ::
                      (MonadIO m) => HTMLTableElement -> m HTMLElement
 createTFootUnchecked self
@@ -105,6 +140,14 @@
 createTBody_ self = liftIO (void (js_createTBody (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLTableElement.createTBody Mozilla HTMLTableElement.createTBody documentation> 
+createTBodyUnsafe ::
+                  (MonadIO m, HasCallStack) => HTMLTableElement -> m HTMLElement
+createTBodyUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_createTBody (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLTableElement.createTBody Mozilla HTMLTableElement.createTBody documentation> 
 createTBodyUnchecked ::
                      (MonadIO m) => HTMLTableElement -> m HTMLElement
 createTBodyUnchecked self
@@ -124,6 +167,14 @@
 createCaption_ self = liftIO (void (js_createCaption (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLTableElement.createCaption Mozilla HTMLTableElement.createCaption documentation> 
+createCaptionUnsafe ::
+                    (MonadIO m, HasCallStack) => HTMLTableElement -> m HTMLElement
+createCaptionUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_createCaption (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLTableElement.createCaption Mozilla HTMLTableElement.createCaption documentation> 
 createCaptionUnchecked ::
                        (MonadIO m) => HTMLTableElement -> m HTMLElement
 createCaptionUnchecked self
@@ -151,6 +202,15 @@
 insertRow_ self index = liftIO (void (js_insertRow (self) index))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLTableElement.insertRow Mozilla HTMLTableElement.insertRow documentation> 
+insertRowUnsafe ::
+                (MonadIO m, HasCallStack) =>
+                  HTMLTableElement -> Int -> m HTMLElement
+insertRowUnsafe self index
+  = liftIO
+      ((nullableToMaybe <$> (js_insertRow (self) index)) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLTableElement.insertRow Mozilla HTMLTableElement.insertRow documentation> 
 insertRowUnchecked ::
                    (MonadIO m) => HTMLTableElement -> Int -> m HTMLElement
 insertRowUnchecked self index
@@ -186,6 +246,15 @@
   = liftIO (nullableToMaybe <$> (js_getCaption (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLTableElement.caption Mozilla HTMLTableElement.caption documentation> 
+getCaptionUnsafe ::
+                 (MonadIO m, HasCallStack) =>
+                   HTMLTableElement -> m HTMLTableCaptionElement
+getCaptionUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getCaption (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLTableElement.caption Mozilla HTMLTableElement.caption documentation> 
 getCaptionUnchecked ::
                     (MonadIO m) => HTMLTableElement -> m HTMLTableCaptionElement
 getCaptionUnchecked self
@@ -211,6 +280,15 @@
 getTHead self = liftIO (nullableToMaybe <$> (js_getTHead (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLTableElement.tHead Mozilla HTMLTableElement.tHead documentation> 
+getTHeadUnsafe ::
+               (MonadIO m, HasCallStack) =>
+                 HTMLTableElement -> m HTMLTableSectionElement
+getTHeadUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getTHead (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLTableElement.tHead Mozilla HTMLTableElement.tHead documentation> 
 getTHeadUnchecked ::
                   (MonadIO m) => HTMLTableElement -> m HTMLTableSectionElement
 getTHeadUnchecked self
@@ -236,6 +314,15 @@
 getTFoot self = liftIO (nullableToMaybe <$> (js_getTFoot (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLTableElement.tFoot Mozilla HTMLTableElement.tFoot documentation> 
+getTFootUnsafe ::
+               (MonadIO m, HasCallStack) =>
+                 HTMLTableElement -> m HTMLTableSectionElement
+getTFootUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getTFoot (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLTableElement.tFoot Mozilla HTMLTableElement.tFoot documentation> 
 getTFootUnchecked ::
                   (MonadIO m) => HTMLTableElement -> m HTMLTableSectionElement
 getTFootUnchecked self
@@ -250,6 +337,14 @@
 getRows self = liftIO (nullableToMaybe <$> (js_getRows (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLTableElement.rows Mozilla HTMLTableElement.rows documentation> 
+getRowsUnsafe ::
+              (MonadIO m, HasCallStack) => HTMLTableElement -> m HTMLCollection
+getRowsUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getRows (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLTableElement.rows Mozilla HTMLTableElement.rows documentation> 
 getRowsUnchecked ::
                  (MonadIO m) => HTMLTableElement -> m HTMLCollection
 getRowsUnchecked self
@@ -263,6 +358,14 @@
            (MonadIO m) => HTMLTableElement -> m (Maybe HTMLCollection)
 getTBodies self
   = liftIO (nullableToMaybe <$> (js_getTBodies (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLTableElement.tBodies Mozilla HTMLTableElement.tBodies documentation> 
+getTBodiesUnsafe ::
+                 (MonadIO m, HasCallStack) => HTMLTableElement -> m HTMLCollection
+getTBodiesUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getTBodies (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLTableElement.tBodies Mozilla HTMLTableElement.tBodies documentation> 
 getTBodiesUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/HTMLTableRowElement.hs b/src/GHCJS/DOM/JSFFI/Generated/HTMLTableRowElement.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/HTMLTableRowElement.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/HTMLTableRowElement.hs
@@ -1,16 +1,22 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.HTMLTableRowElement
-       (js_insertCell, insertCell, insertCell_, insertCellUnchecked,
-        js_deleteCell, deleteCell, js_getRowIndex, getRowIndex,
-        js_getSectionRowIndex, getSectionRowIndex, js_getCells, getCells,
-        getCellsUnchecked, js_setAlign, setAlign, js_getAlign, getAlign,
-        js_setBgColor, setBgColor, js_getBgColor, getBgColor, js_setCh,
-        setCh, js_getCh, getCh, js_setChOff, setChOff, js_getChOff,
-        getChOff, js_setVAlign, setVAlign, js_getVAlign, getVAlign,
-        HTMLTableRowElement, castToHTMLTableRowElement,
+       (js_insertCell, insertCell, insertCell_, insertCellUnsafe,
+        insertCellUnchecked, js_deleteCell, deleteCell, js_getRowIndex,
+        getRowIndex, js_getSectionRowIndex, getSectionRowIndex,
+        js_getCells, getCells, getCellsUnsafe, getCellsUnchecked,
+        js_setAlign, setAlign, js_getAlign, getAlign, js_setBgColor,
+        setBgColor, js_getBgColor, getBgColor, js_setCh, setCh, js_getCh,
+        getCh, js_setChOff, setChOff, js_getChOff, getChOff, js_setVAlign,
+        setVAlign, js_getVAlign, getVAlign, HTMLTableRowElement(..),
         gTypeHTMLTableRowElement)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -26,6 +32,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"insertCell\"]($2)"
         js_insertCell ::
@@ -42,6 +58,15 @@
 insertCell_ self index = liftIO (void (js_insertCell (self) index))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLTableRowElement.insertCell Mozilla HTMLTableRowElement.insertCell documentation> 
+insertCellUnsafe ::
+                 (MonadIO m, HasCallStack) =>
+                   HTMLTableRowElement -> Int -> m HTMLElement
+insertCellUnsafe self index
+  = liftIO
+      ((nullableToMaybe <$> (js_insertCell (self) index)) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLTableRowElement.insertCell Mozilla HTMLTableRowElement.insertCell documentation> 
 insertCellUnchecked ::
                     (MonadIO m) => HTMLTableRowElement -> Int -> m HTMLElement
 insertCellUnchecked self index
@@ -76,6 +101,15 @@
 getCells ::
          (MonadIO m) => HTMLTableRowElement -> m (Maybe HTMLCollection)
 getCells self = liftIO (nullableToMaybe <$> (js_getCells (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLTableRowElement.cells Mozilla HTMLTableRowElement.cells documentation> 
+getCellsUnsafe ::
+               (MonadIO m, HasCallStack) =>
+                 HTMLTableRowElement -> m HTMLCollection
+getCellsUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getCells (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLTableRowElement.cells Mozilla HTMLTableRowElement.cells documentation> 
 getCellsUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/HTMLTableSectionElement.hs b/src/GHCJS/DOM/JSFFI/Generated/HTMLTableSectionElement.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/HTMLTableSectionElement.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/HTMLTableSectionElement.hs
@@ -1,14 +1,20 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.HTMLTableSectionElement
-       (js_insertRow, insertRow, insertRow_, insertRowUnchecked,
-        js_deleteRow, deleteRow, js_setAlign, setAlign, js_getAlign,
-        getAlign, js_setCh, setCh, js_getCh, getCh, js_setChOff, setChOff,
-        js_getChOff, getChOff, js_setVAlign, setVAlign, js_getVAlign,
-        getVAlign, js_getRows, getRows, getRowsUnchecked,
-        HTMLTableSectionElement, castToHTMLTableSectionElement,
+       (js_insertRow, insertRow, insertRow_, insertRowUnsafe,
+        insertRowUnchecked, js_deleteRow, deleteRow, js_setAlign, setAlign,
+        js_getAlign, getAlign, js_setCh, setCh, js_getCh, getCh,
+        js_setChOff, setChOff, js_getChOff, getChOff, js_setVAlign,
+        setVAlign, js_getVAlign, getVAlign, js_getRows, getRows,
+        getRowsUnsafe, getRowsUnchecked, HTMLTableSectionElement(..),
         gTypeHTMLTableSectionElement)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -24,6 +30,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"insertRow\"]($2)"
         js_insertRow ::
@@ -41,6 +57,15 @@
 insertRow_ self index = liftIO (void (js_insertRow (self) index))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLTableSectionElement.insertRow Mozilla HTMLTableSectionElement.insertRow documentation> 
+insertRowUnsafe ::
+                (MonadIO m, HasCallStack) =>
+                  HTMLTableSectionElement -> Int -> m HTMLElement
+insertRowUnsafe self index
+  = liftIO
+      ((nullableToMaybe <$> (js_insertRow (self) index)) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLTableSectionElement.insertRow Mozilla HTMLTableSectionElement.insertRow documentation> 
 insertRowUnchecked ::
                    (MonadIO m) => HTMLTableSectionElement -> Int -> m HTMLElement
 insertRowUnchecked self index
@@ -133,6 +158,15 @@
 getRows ::
         (MonadIO m) => HTMLTableSectionElement -> m (Maybe HTMLCollection)
 getRows self = liftIO (nullableToMaybe <$> (js_getRows (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLTableSectionElement.rows Mozilla HTMLTableSectionElement.rows documentation> 
+getRowsUnsafe ::
+              (MonadIO m, HasCallStack) =>
+                HTMLTableSectionElement -> m HTMLCollection
+getRowsUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getRows (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLTableSectionElement.rows Mozilla HTMLTableSectionElement.rows documentation> 
 getRowsUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/HTMLTemplateElement.hs b/src/GHCJS/DOM/JSFFI/Generated/HTMLTemplateElement.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/HTMLTemplateElement.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/HTMLTemplateElement.hs
@@ -1,10 +1,15 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.HTMLTemplateElement
-       (js_getContent, getContent, getContentUnchecked,
-        HTMLTemplateElement, castToHTMLTemplateElement,
-        gTypeHTMLTemplateElement)
+       (js_getContent, getContent, getContentUnsafe, getContentUnchecked,
+        HTMLTemplateElement(..), gTypeHTMLTemplateElement)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -20,6 +25,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"content\"]" js_getContent ::
         HTMLTemplateElement -> IO (Nullable DocumentFragment)
@@ -29,6 +44,15 @@
            (MonadIO m) => HTMLTemplateElement -> m (Maybe DocumentFragment)
 getContent self
   = liftIO (nullableToMaybe <$> (js_getContent (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLTemplateElement.content Mozilla HTMLTemplateElement.content documentation> 
+getContentUnsafe ::
+                 (MonadIO m, HasCallStack) =>
+                   HTMLTemplateElement -> m DocumentFragment
+getContentUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getContent (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLTemplateElement.content Mozilla HTMLTemplateElement.content documentation> 
 getContentUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/HTMLTextAreaElement.hs b/src/GHCJS/DOM/JSFFI/Generated/HTMLTextAreaElement.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/HTMLTextAreaElement.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/HTMLTextAreaElement.hs
@@ -1,4 +1,9 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.HTMLTextAreaElement
        (js_checkValidity, checkValidity, checkValidity_,
         js_setCustomValidity, setCustomValidity, js_select, select,
@@ -7,7 +12,7 @@
         setAutofocus, js_getAutofocus, getAutofocus, js_setCols, setCols,
         js_getCols, getCols, js_setDirName, setDirName, js_getDirName,
         getDirName, js_setDisabled, setDisabled, js_getDisabled,
-        getDisabled, js_getForm, getForm, getFormUnchecked,
+        getDisabled, js_getForm, getForm, getFormUnsafe, getFormUnchecked,
         js_setMaxLength, setMaxLength, js_getMaxLength, getMaxLength,
         js_setName, setName, js_getName, getName, js_setPlaceholder,
         setPlaceholder, js_getPlaceholder, getPlaceholder, js_setReadOnly,
@@ -15,22 +20,25 @@
         setRequired, js_getRequired, getRequired, js_setRows, setRows,
         js_getRows, getRows, js_setWrap, setWrap, js_getWrap, getWrap,
         js_getType, getType, js_setDefaultValue, setDefaultValue,
-        js_getDefaultValue, getDefaultValue, getDefaultValueUnchecked,
-        js_setValue, setValue, js_getValue, getValue, getValueUnchecked,
-        js_getTextLength, getTextLength, js_getWillValidate,
-        getWillValidate, js_getValidity, getValidity, getValidityUnchecked,
+        js_getDefaultValue, getDefaultValue, getDefaultValueUnsafe,
+        getDefaultValueUnchecked, js_setValue, setValue, js_getValue,
+        getValue, getValueUnsafe, getValueUnchecked, js_getTextLength,
+        getTextLength, js_getWillValidate, getWillValidate, js_getValidity,
+        getValidity, getValidityUnsafe, getValidityUnchecked,
         js_getValidationMessage, getValidationMessage, js_getLabels,
-        getLabels, getLabelsUnchecked, js_setSelectionStart,
-        setSelectionStart, js_getSelectionStart, getSelectionStart,
-        js_setSelectionEnd, setSelectionEnd, js_getSelectionEnd,
-        getSelectionEnd, js_setSelectionDirection, setSelectionDirection,
-        js_getSelectionDirection, getSelectionDirection, js_setAutocorrect,
-        setAutocorrect, js_getAutocorrect, getAutocorrect,
-        js_setAutocapitalize, setAutocapitalize, js_getAutocapitalize,
-        getAutocapitalize, getAutocapitalizeUnchecked, HTMLTextAreaElement,
-        castToHTMLTextAreaElement, gTypeHTMLTextAreaElement)
+        getLabels, getLabelsUnsafe, getLabelsUnchecked,
+        js_setSelectionStart, setSelectionStart, js_getSelectionStart,
+        getSelectionStart, js_setSelectionEnd, setSelectionEnd,
+        js_getSelectionEnd, getSelectionEnd, js_setSelectionDirection,
+        setSelectionDirection, js_getSelectionDirection,
+        getSelectionDirection, js_setAutocorrect, setAutocorrect,
+        js_getAutocorrect, getAutocorrect, js_setAutocapitalize,
+        setAutocapitalize, js_getAutocapitalize, getAutocapitalize,
+        getAutocapitalizeUnsafe, getAutocapitalizeUnchecked,
+        HTMLTextAreaElement(..), gTypeHTMLTextAreaElement)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -46,6 +54,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe
         "($1[\"checkValidity\"]() ? 1 : 0)" js_checkValidity ::
@@ -182,6 +200,15 @@
 getForm self = liftIO (nullableToMaybe <$> (js_getForm (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLTextAreaElement.form Mozilla HTMLTextAreaElement.form documentation> 
+getFormUnsafe ::
+              (MonadIO m, HasCallStack) =>
+                HTMLTextAreaElement -> m HTMLFormElement
+getFormUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getForm (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLTextAreaElement.form Mozilla HTMLTextAreaElement.form documentation> 
 getFormUnchecked ::
                  (MonadIO m) => HTMLTextAreaElement -> m HTMLFormElement
 getFormUnchecked self
@@ -323,6 +350,15 @@
   = liftIO (fromMaybeJSString <$> (js_getDefaultValue (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLTextAreaElement.defaultValue Mozilla HTMLTextAreaElement.defaultValue documentation> 
+getDefaultValueUnsafe ::
+                      (MonadIO m, HasCallStack, FromJSString result) =>
+                        HTMLTextAreaElement -> m result
+getDefaultValueUnsafe self
+  = liftIO
+      ((fromMaybeJSString <$> (js_getDefaultValue (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLTextAreaElement.defaultValue Mozilla HTMLTextAreaElement.defaultValue documentation> 
 getDefaultValueUnchecked ::
                          (MonadIO m, FromJSString result) => HTMLTextAreaElement -> m result
 getDefaultValueUnchecked self
@@ -349,6 +385,15 @@
 getValue self = liftIO (fromMaybeJSString <$> (js_getValue (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLTextAreaElement.value Mozilla HTMLTextAreaElement.value documentation> 
+getValueUnsafe ::
+               (MonadIO m, HasCallStack, FromJSString result) =>
+                 HTMLTextAreaElement -> m result
+getValueUnsafe self
+  = liftIO
+      ((fromMaybeJSString <$> (js_getValue (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLTextAreaElement.value Mozilla HTMLTextAreaElement.value documentation> 
 getValueUnchecked ::
                   (MonadIO m, FromJSString result) => HTMLTextAreaElement -> m result
 getValueUnchecked self
@@ -378,6 +423,14 @@
   = liftIO (nullableToMaybe <$> (js_getValidity (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLTextAreaElement.validity Mozilla HTMLTextAreaElement.validity documentation> 
+getValidityUnsafe ::
+                  (MonadIO m, HasCallStack) => HTMLTextAreaElement -> m ValidityState
+getValidityUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getValidity (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLTextAreaElement.validity Mozilla HTMLTextAreaElement.validity documentation> 
 getValidityUnchecked ::
                      (MonadIO m) => HTMLTextAreaElement -> m ValidityState
 getValidityUnchecked self
@@ -401,6 +454,14 @@
 getLabels self = liftIO (nullableToMaybe <$> (js_getLabels (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLTextAreaElement.labels Mozilla HTMLTextAreaElement.labels documentation> 
+getLabelsUnsafe ::
+                (MonadIO m, HasCallStack) => HTMLTextAreaElement -> m NodeList
+getLabelsUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getLabels (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLTextAreaElement.labels Mozilla HTMLTextAreaElement.labels documentation> 
 getLabelsUnchecked ::
                    (MonadIO m) => HTMLTextAreaElement -> m NodeList
 getLabelsUnchecked self
@@ -492,6 +553,15 @@
                     HTMLTextAreaElement -> m (Maybe result)
 getAutocapitalize self
   = liftIO (fromMaybeJSString <$> (js_getAutocapitalize (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLTextAreaElement.autocapitalize Mozilla HTMLTextAreaElement.autocapitalize documentation> 
+getAutocapitalizeUnsafe ::
+                        (MonadIO m, HasCallStack, FromJSString result) =>
+                          HTMLTextAreaElement -> m result
+getAutocapitalizeUnsafe self
+  = liftIO
+      ((fromMaybeJSString <$> (js_getAutocapitalize (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLTextAreaElement.autocapitalize Mozilla HTMLTextAreaElement.autocapitalize documentation> 
 getAutocapitalizeUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/HTMLTitleElement.hs b/src/GHCJS/DOM/JSFFI/Generated/HTMLTitleElement.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/HTMLTitleElement.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/HTMLTitleElement.hs
@@ -1,9 +1,15 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.HTMLTitleElement
-       (js_setText, setText, js_getText, getText, getTextUnchecked,
-        HTMLTitleElement, castToHTMLTitleElement, gTypeHTMLTitleElement)
+       (js_setText, setText, js_getText, getText, getTextUnsafe,
+        getTextUnchecked, HTMLTitleElement(..), gTypeHTMLTitleElement)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -19,6 +25,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"text\"] = $2;" js_setText ::
         HTMLTitleElement -> Nullable JSString -> IO ()
@@ -37,6 +53,15 @@
         (MonadIO m, FromJSString result) =>
           HTMLTitleElement -> m (Maybe result)
 getText self = liftIO (fromMaybeJSString <$> (js_getText (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLTitleElement.text Mozilla HTMLTitleElement.text documentation> 
+getTextUnsafe ::
+              (MonadIO m, HasCallStack, FromJSString result) =>
+                HTMLTitleElement -> m result
+getTextUnsafe self
+  = liftIO
+      ((fromMaybeJSString <$> (js_getText (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLTitleElement.text Mozilla HTMLTitleElement.text documentation> 
 getTextUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/HTMLTrackElement.hs b/src/GHCJS/DOM/JSFFI/Generated/HTMLTrackElement.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/HTMLTrackElement.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/HTMLTrackElement.hs
@@ -1,4 +1,9 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.HTMLTrackElement
        (pattern NONE, pattern LOADING, pattern LOADED, pattern ERROR,
         js_setKind, setKind, js_getKind, getKind, js_setSrc, setSrc,
@@ -6,10 +11,11 @@
         getSrclang, js_setLabel, setLabel, js_getLabel, getLabel,
         js_setDefault, setDefault, js_getDefault, getDefault,
         js_getReadyState, getReadyState, js_getTrack, getTrack,
-        getTrackUnchecked, HTMLTrackElement, castToHTMLTrackElement,
+        getTrackUnsafe, getTrackUnchecked, HTMLTrackElement(..),
         gTypeHTMLTrackElement)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -25,6 +31,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
 pattern NONE = 0
 pattern LOADING = 1
 pattern LOADED = 2
@@ -122,6 +138,14 @@
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLTrackElement.track Mozilla HTMLTrackElement.track documentation> 
 getTrack :: (MonadIO m) => HTMLTrackElement -> m (Maybe TextTrack)
 getTrack self = liftIO (nullableToMaybe <$> (js_getTrack (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLTrackElement.track Mozilla HTMLTrackElement.track documentation> 
+getTrackUnsafe ::
+               (MonadIO m, HasCallStack) => HTMLTrackElement -> m TextTrack
+getTrackUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getTrack (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/HTMLTrackElement.track Mozilla HTMLTrackElement.track documentation> 
 getTrackUnchecked :: (MonadIO m) => HTMLTrackElement -> m TextTrack
diff --git a/src/GHCJS/DOM/JSFFI/Generated/HTMLUListElement.hs b/src/GHCJS/DOM/JSFFI/Generated/HTMLUListElement.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/HTMLUListElement.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/HTMLUListElement.hs
@@ -1,10 +1,16 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.HTMLUListElement
        (js_setCompact, setCompact, js_getCompact, getCompact, js_setType,
-        setType, js_getType, getType, HTMLUListElement,
-        castToHTMLUListElement, gTypeHTMLUListElement)
+        setType, js_getType, getType, HTMLUListElement(..),
+        gTypeHTMLUListElement)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -20,6 +26,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"compact\"] = $2;"
         js_setCompact :: HTMLUListElement -> Bool -> IO ()
diff --git a/src/GHCJS/DOM/JSFFI/Generated/HTMLVideoElement.hs b/src/GHCJS/DOM/JSFFI/Generated/HTMLVideoElement.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/HTMLVideoElement.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/HTMLVideoElement.hs
@@ -1,4 +1,9 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.HTMLVideoElement
        (js_webkitEnterFullscreen, webkitEnterFullscreen,
         js_webkitExitFullscreen, webkitExitFullscreen,
@@ -19,10 +24,11 @@
         js_getWebkitDecodedFrameCount, getWebkitDecodedFrameCount,
         js_getWebkitDroppedFrameCount, getWebkitDroppedFrameCount,
         js_getWebkitPresentationMode, getWebkitPresentationMode,
-        webKitPresentationModeChanged, HTMLVideoElement,
-        castToHTMLVideoElement, gTypeHTMLVideoElement)
+        webKitPresentationModeChanged, HTMLVideoElement(..),
+        gTypeHTMLVideoElement)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -38,6 +44,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"webkitEnterFullscreen\"]()"
         js_webkitEnterFullscreen :: HTMLVideoElement -> IO ()
diff --git a/src/GHCJS/DOM/JSFFI/Generated/HashChangeEvent.hs b/src/GHCJS/DOM/JSFFI/Generated/HashChangeEvent.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/HashChangeEvent.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/HashChangeEvent.hs
@@ -1,10 +1,16 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.HashChangeEvent
        (js_initHashChangeEvent, initHashChangeEvent, js_getOldURL,
-        getOldURL, js_getNewURL, getNewURL, HashChangeEvent,
-        castToHashChangeEvent, gTypeHashChangeEvent)
+        getOldURL, js_getNewURL, getNewURL, HashChangeEvent(..),
+        gTypeHashChangeEvent)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -20,6 +26,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe
         "$1[\"initHashChangeEvent\"]($2,\n$3, $4, $5, $6)"
diff --git a/src/GHCJS/DOM/JSFFI/Generated/History.hs b/src/GHCJS/DOM/JSFFI/Generated/History.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/History.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/History.hs
@@ -1,11 +1,17 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.History
        (js_back, back, js_forward, forward, js_go, go, js_pushState,
         pushState, js_replaceState, replaceState, js_getLength, getLength,
-        js_getState, getState, getStateUnchecked, History, castToHistory,
-        gTypeHistory)
+        js_getState, getState, getStateUnsafe, getStateUnchecked,
+        History(..), gTypeHistory)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -21,6 +27,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"back\"]()" js_back ::
         History -> IO ()
@@ -80,6 +96,14 @@
 getState ::
          (MonadIO m) => History -> m (Maybe SerializedScriptValue)
 getState self = liftIO (nullableToMaybe <$> (js_getState (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/History.state Mozilla History.state documentation> 
+getStateUnsafe ::
+               (MonadIO m, HasCallStack) => History -> m SerializedScriptValue
+getStateUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getState (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/History.state Mozilla History.state documentation> 
 getStateUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/IDBCursor.hs b/src/GHCJS/DOM/JSFFI/Generated/IDBCursor.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/IDBCursor.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/IDBCursor.hs
@@ -1,13 +1,19 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.IDBCursor
-       (js_update, update, update_, updateUnchecked, js_advance, advance,
-        js_continue, continue, js_delete, delete, delete_, deleteUnchecked,
-        js_getSource, getSource, getSourceUnchecked, js_getDirection,
-        getDirection, js_getKey, getKey, js_getPrimaryKey, getPrimaryKey,
-        IDBCursor, castToIDBCursor, gTypeIDBCursor, IsIDBCursor,
-        toIDBCursor)
+       (js_update, update, update_, updateUnsafe, updateUnchecked,
+        js_advance, advance, js_continue, continue, js_delete, delete,
+        delete_, deleteUnsafe, deleteUnchecked, js_getSource, getSource,
+        getSourceUnsafe, getSourceUnchecked, js_getDirection, getDirection,
+        js_getKey, getKey, js_getPrimaryKey, getPrimaryKey, IDBCursor(..),
+        gTypeIDBCursor, IsIDBCursor, toIDBCursor)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -23,6 +29,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"update\"]($2)" js_update ::
         IDBCursor -> JSVal -> IO (Nullable IDBRequest)
@@ -40,6 +56,15 @@
   = liftIO (void (js_update (toIDBCursor self) value))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/IDBCursor.update Mozilla IDBCursor.update documentation> 
+updateUnsafe ::
+             (MonadIO m, IsIDBCursor self, HasCallStack) =>
+               self -> JSVal -> m IDBRequest
+updateUnsafe self value
+  = liftIO
+      ((nullableToMaybe <$> (js_update (toIDBCursor self) value)) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/IDBCursor.update Mozilla IDBCursor.update documentation> 
 updateUnchecked ::
                 (MonadIO m, IsIDBCursor self) => self -> JSVal -> m IDBRequest
 updateUnchecked self value
@@ -75,6 +100,14 @@
 delete_ self = liftIO (void (js_delete (toIDBCursor self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/IDBCursor.delete Mozilla IDBCursor.delete documentation> 
+deleteUnsafe ::
+             (MonadIO m, IsIDBCursor self, HasCallStack) => self -> m IDBRequest
+deleteUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_delete (toIDBCursor self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/IDBCursor.delete Mozilla IDBCursor.delete documentation> 
 deleteUnchecked ::
                 (MonadIO m, IsIDBCursor self) => self -> m IDBRequest
 deleteUnchecked self
@@ -89,6 +122,14 @@
           (MonadIO m, IsIDBCursor self) => self -> m (Maybe IDBAny)
 getSource self
   = liftIO (nullableToMaybe <$> (js_getSource (toIDBCursor self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/IDBCursor.source Mozilla IDBCursor.source documentation> 
+getSourceUnsafe ::
+                (MonadIO m, IsIDBCursor self, HasCallStack) => self -> m IDBAny
+getSourceUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getSource (toIDBCursor self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/IDBCursor.source Mozilla IDBCursor.source documentation> 
 getSourceUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/IDBCursorWithValue.hs b/src/GHCJS/DOM/JSFFI/Generated/IDBCursorWithValue.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/IDBCursorWithValue.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/IDBCursorWithValue.hs
@@ -1,9 +1,15 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.IDBCursorWithValue
-       (js_getValue, getValue, IDBCursorWithValue,
-        castToIDBCursorWithValue, gTypeIDBCursorWithValue)
+       (js_getValue, getValue, IDBCursorWithValue(..),
+        gTypeIDBCursorWithValue)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -19,6 +25,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"value\"]" js_getValue ::
         IDBCursorWithValue -> IO JSVal
diff --git a/src/GHCJS/DOM/JSFFI/Generated/IDBDatabase.hs b/src/GHCJS/DOM/JSFFI/Generated/IDBDatabase.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/IDBDatabase.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/IDBDatabase.hs
@@ -1,15 +1,23 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.IDBDatabase
        (js_createObjectStore, createObjectStore, createObjectStore_,
-        createObjectStoreUnchecked, js_deleteObjectStore,
-        deleteObjectStore, js_transaction, transaction, transaction_,
-        transactionUnchecked, js_transaction', transaction', transaction'_,
+        createObjectStoreUnsafe, createObjectStoreUnchecked,
+        js_deleteObjectStore, deleteObjectStore, js_transaction,
+        transaction, transaction_, transactionUnsafe, transactionUnchecked,
+        js_transaction', transaction', transaction'_, transaction'Unsafe,
         transaction'Unchecked, js_close, close, js_getName, getName,
         js_getVersion, getVersion, js_getObjectStoreNames,
-        getObjectStoreNames, getObjectStoreNamesUnchecked, abort, error,
-        versionChange, IDBDatabase, castToIDBDatabase, gTypeIDBDatabase)
+        getObjectStoreNames, getObjectStoreNamesUnsafe,
+        getObjectStoreNamesUnchecked, abort, error, versionChange,
+        IDBDatabase(..), gTypeIDBDatabase)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -25,6 +33,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe
         "$1[\"createObjectStore\"]($2, $3)" js_createObjectStore ::
@@ -52,6 +70,17 @@
             (maybeToNullable (fmap toDictionary options))))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/IDBDatabase.createObjectStore Mozilla IDBDatabase.createObjectStore documentation> 
+createObjectStoreUnsafe ::
+                        (MonadIO m, ToJSString name, IsDictionary options, HasCallStack) =>
+                          IDBDatabase -> name -> Maybe options -> m IDBObjectStore
+createObjectStoreUnsafe self name options
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_createObjectStore (self) (toJSString name)
+             (maybeToNullable (fmap toDictionary options))))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/IDBDatabase.createObjectStore Mozilla IDBDatabase.createObjectStore documentation> 
 createObjectStoreUnchecked ::
                            (MonadIO m, ToJSString name, IsDictionary options) =>
                              IDBDatabase -> name -> Maybe options -> m IDBObjectStore
@@ -93,6 +122,16 @@
          (js_transaction (self) (toJSString storeName) (toJSString mode)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/IDBDatabase.transaction Mozilla IDBDatabase.transaction documentation> 
+transactionUnsafe ::
+                  (MonadIO m, ToJSString storeName, ToJSString mode, HasCallStack) =>
+                    IDBDatabase -> storeName -> mode -> m IDBTransaction
+transactionUnsafe self storeName mode
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_transaction (self) (toJSString storeName) (toJSString mode)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/IDBDatabase.transaction Mozilla IDBDatabase.transaction documentation> 
 transactionUnchecked ::
                      (MonadIO m, ToJSString storeName, ToJSString mode) =>
                        IDBDatabase -> storeName -> mode -> m IDBTransaction
@@ -128,6 +167,19 @@
             (toJSString mode)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/IDBDatabase.transaction Mozilla IDBDatabase.transaction documentation> 
+transaction'Unsafe ::
+                   (MonadIO m, ToJSString storeNames, ToJSString mode,
+                    HasCallStack) =>
+                     IDBDatabase -> [storeNames] -> mode -> m IDBTransaction
+transaction'Unsafe self storeNames mode
+  = liftIO
+      ((nullableToMaybe <$>
+          (toJSVal storeNames >>=
+             \ storeNames' -> js_transaction' (self) storeNames'
+             (toJSString mode)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/IDBDatabase.transaction Mozilla IDBDatabase.transaction documentation> 
 transaction'Unchecked ::
                       (MonadIO m, ToJSString storeNames, ToJSString mode) =>
                         IDBDatabase -> [storeNames] -> mode -> m IDBTransaction
@@ -169,6 +221,14 @@
                     (MonadIO m) => IDBDatabase -> m (Maybe DOMStringList)
 getObjectStoreNames self
   = liftIO (nullableToMaybe <$> (js_getObjectStoreNames (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/IDBDatabase.objectStoreNames Mozilla IDBDatabase.objectStoreNames documentation> 
+getObjectStoreNamesUnsafe ::
+                          (MonadIO m, HasCallStack) => IDBDatabase -> m DOMStringList
+getObjectStoreNamesUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getObjectStoreNames (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/IDBDatabase.objectStoreNames Mozilla IDBDatabase.objectStoreNames documentation> 
 getObjectStoreNamesUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/IDBFactory.hs b/src/GHCJS/DOM/JSFFI/Generated/IDBFactory.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/IDBFactory.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/IDBFactory.hs
@@ -1,10 +1,17 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.IDBFactory
-       (js_open, open, open_, openUnchecked, js_deleteDatabase,
-        deleteDatabase, deleteDatabase_, deleteDatabaseUnchecked, js_cmp,
-        cmp, cmp_, IDBFactory, castToIDBFactory, gTypeIDBFactory)
+       (js_open, open, open_, openUnsafe, openUnchecked,
+        js_deleteDatabase, deleteDatabase, deleteDatabase_,
+        deleteDatabaseUnsafe, deleteDatabaseUnchecked, js_cmp, cmp, cmp_,
+        IDBFactory(..), gTypeIDBFactory)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -20,6 +27,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"open\"]($2, $3)" js_open ::
         IDBFactory -> JSString -> Double -> IO (Nullable IDBOpenDBRequest)
@@ -42,6 +59,16 @@
       (void (js_open (self) (toJSString name) (fromIntegral version)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/IDBFactory.open Mozilla IDBFactory.open documentation> 
+openUnsafe ::
+           (MonadIO m, ToJSString name, HasCallStack) =>
+             IDBFactory -> name -> Word64 -> m IDBOpenDBRequest
+openUnsafe self name version
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_open (self) (toJSString name) (fromIntegral version)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/IDBFactory.open Mozilla IDBFactory.open documentation> 
 openUnchecked ::
               (MonadIO m, ToJSString name) =>
                 IDBFactory -> name -> Word64 -> m IDBOpenDBRequest
@@ -67,6 +94,15 @@
                 (MonadIO m, ToJSString name) => IDBFactory -> name -> m ()
 deleteDatabase_ self name
   = liftIO (void (js_deleteDatabase (self) (toJSString name)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/IDBFactory.deleteDatabase Mozilla IDBFactory.deleteDatabase documentation> 
+deleteDatabaseUnsafe ::
+                     (MonadIO m, ToJSString name, HasCallStack) =>
+                       IDBFactory -> name -> m IDBOpenDBRequest
+deleteDatabaseUnsafe self name
+  = liftIO
+      ((nullableToMaybe <$> (js_deleteDatabase (self) (toJSString name)))
+         >>= maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/IDBFactory.deleteDatabase Mozilla IDBFactory.deleteDatabase documentation> 
 deleteDatabaseUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/IDBIndex.hs b/src/GHCJS/DOM/JSFFI/Generated/IDBIndex.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/IDBIndex.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/IDBIndex.hs
@@ -1,21 +1,31 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.IDBIndex
        (js_openCursorRange, openCursorRange, openCursorRange_,
-        openCursorRangeUnchecked, js_openCursor, openCursor, openCursor_,
-        openCursorUnchecked, js_openKeyCursorRange, openKeyCursorRange,
-        openKeyCursorRange_, openKeyCursorRangeUnchecked, js_openKeyCursor,
-        openKeyCursor, openKeyCursor_, openKeyCursorUnchecked, js_getRange,
-        getRange, getRange_, getRangeUnchecked, js_get, get, get_,
-        getUnchecked, js_getKeyRange, getKeyRange, getKeyRange_,
-        getKeyRangeUnchecked, js_getKey, getKey, getKey_, getKeyUnchecked,
-        js_countRange, countRange, countRange_, countRangeUnchecked,
-        js_count, count, count_, countUnchecked, js_getName, getName,
-        js_getObjectStore, getObjectStore, getObjectStoreUnchecked,
-        js_getKeyPath, getKeyPath, getKeyPathUnchecked, js_getMultiEntry,
-        getMultiEntry, js_getUnique, getUnique, IDBIndex, castToIDBIndex,
+        openCursorRangeUnsafe, openCursorRangeUnchecked, js_openCursor,
+        openCursor, openCursor_, openCursorUnsafe, openCursorUnchecked,
+        js_openKeyCursorRange, openKeyCursorRange, openKeyCursorRange_,
+        openKeyCursorRangeUnsafe, openKeyCursorRangeUnchecked,
+        js_openKeyCursor, openKeyCursor, openKeyCursor_,
+        openKeyCursorUnsafe, openKeyCursorUnchecked, js_getRange, getRange,
+        getRange_, getRangeUnsafe, getRangeUnchecked, js_get, get, get_,
+        getUnsafe, getUnchecked, js_getKeyRange, getKeyRange, getKeyRange_,
+        getKeyRangeUnsafe, getKeyRangeUnchecked, js_getKey, getKey,
+        getKey_, getKeyUnsafe, getKeyUnchecked, js_countRange, countRange,
+        countRange_, countRangeUnsafe, countRangeUnchecked, js_count,
+        count, count_, countUnsafe, countUnchecked, js_getName, getName,
+        js_getObjectStore, getObjectStore, getObjectStoreUnsafe,
+        getObjectStoreUnchecked, js_getKeyPath, getKeyPath,
+        getKeyPathUnsafe, getKeyPathUnchecked, js_getMultiEntry,
+        getMultiEntry, js_getUnique, getUnique, IDBIndex(..),
         gTypeIDBIndex)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -31,6 +41,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"openCursor\"]($2, $3)"
         js_openCursorRange ::
@@ -58,6 +78,17 @@
             (toJSString direction)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/IDBIndex.openCursor Mozilla IDBIndex.openCursor documentation> 
+openCursorRangeUnsafe ::
+                      (MonadIO m, ToJSString direction, HasCallStack) =>
+                        IDBIndex -> Maybe IDBKeyRange -> direction -> m IDBRequest
+openCursorRangeUnsafe self range direction
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_openCursorRange (self) (maybeToNullable range)
+             (toJSString direction)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/IDBIndex.openCursor Mozilla IDBIndex.openCursor documentation> 
 openCursorRangeUnchecked ::
                          (MonadIO m, ToJSString direction) =>
                            IDBIndex -> Maybe IDBKeyRange -> direction -> m IDBRequest
@@ -88,6 +119,16 @@
   = liftIO (void (js_openCursor (self) key (toJSString direction)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/IDBIndex.openCursor Mozilla IDBIndex.openCursor documentation> 
+openCursorUnsafe ::
+                 (MonadIO m, ToJSString direction, HasCallStack) =>
+                   IDBIndex -> JSVal -> direction -> m IDBRequest
+openCursorUnsafe self key direction
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_openCursor (self) key (toJSString direction)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/IDBIndex.openCursor Mozilla IDBIndex.openCursor documentation> 
 openCursorUnchecked ::
                     (MonadIO m, ToJSString direction) =>
                       IDBIndex -> JSVal -> direction -> m IDBRequest
@@ -122,6 +163,17 @@
             (toJSString direction)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/IDBIndex.openKeyCursor Mozilla IDBIndex.openKeyCursor documentation> 
+openKeyCursorRangeUnsafe ::
+                         (MonadIO m, ToJSString direction, HasCallStack) =>
+                           IDBIndex -> Maybe IDBKeyRange -> direction -> m IDBRequest
+openKeyCursorRangeUnsafe self range direction
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_openKeyCursorRange (self) (maybeToNullable range)
+             (toJSString direction)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/IDBIndex.openKeyCursor Mozilla IDBIndex.openKeyCursor documentation> 
 openKeyCursorRangeUnchecked ::
                             (MonadIO m, ToJSString direction) =>
                               IDBIndex -> Maybe IDBKeyRange -> direction -> m IDBRequest
@@ -153,6 +205,16 @@
       (void (js_openKeyCursor (self) key (toJSString direction)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/IDBIndex.openKeyCursor Mozilla IDBIndex.openKeyCursor documentation> 
+openKeyCursorUnsafe ::
+                    (MonadIO m, ToJSString direction, HasCallStack) =>
+                      IDBIndex -> JSVal -> direction -> m IDBRequest
+openKeyCursorUnsafe self key direction
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_openKeyCursor (self) key (toJSString direction)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/IDBIndex.openKeyCursor Mozilla IDBIndex.openKeyCursor documentation> 
 openKeyCursorUnchecked ::
                        (MonadIO m, ToJSString direction) =>
                          IDBIndex -> JSVal -> direction -> m IDBRequest
@@ -178,6 +240,15 @@
   = liftIO (void (js_getRange (self) (maybeToNullable key)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/IDBIndex.get Mozilla IDBIndex.get documentation> 
+getRangeUnsafe ::
+               (MonadIO m, HasCallStack) =>
+                 IDBIndex -> Maybe IDBKeyRange -> m IDBRequest
+getRangeUnsafe self key
+  = liftIO
+      ((nullableToMaybe <$> (js_getRange (self) (maybeToNullable key)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/IDBIndex.get Mozilla IDBIndex.get documentation> 
 getRangeUnchecked ::
                   (MonadIO m) => IDBIndex -> Maybe IDBKeyRange -> m IDBRequest
 getRangeUnchecked self key
@@ -197,6 +268,14 @@
 get_ self key = liftIO (void (js_get (self) key))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/IDBIndex.get Mozilla IDBIndex.get documentation> 
+getUnsafe ::
+          (MonadIO m, HasCallStack) => IDBIndex -> JSVal -> m IDBRequest
+getUnsafe self key
+  = liftIO
+      ((nullableToMaybe <$> (js_get (self) key)) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/IDBIndex.get Mozilla IDBIndex.get documentation> 
 getUnchecked :: (MonadIO m) => IDBIndex -> JSVal -> m IDBRequest
 getUnchecked self key
   = liftIO (fromJust . nullableToMaybe <$> (js_get (self) key))
@@ -220,6 +299,16 @@
   = liftIO (void (js_getKeyRange (self) (maybeToNullable key)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/IDBIndex.getKey Mozilla IDBIndex.getKey documentation> 
+getKeyRangeUnsafe ::
+                  (MonadIO m, HasCallStack) =>
+                    IDBIndex -> Maybe IDBKeyRange -> m IDBRequest
+getKeyRangeUnsafe self key
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_getKeyRange (self) (maybeToNullable key)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/IDBIndex.getKey Mozilla IDBIndex.getKey documentation> 
 getKeyRangeUnchecked ::
                      (MonadIO m) => IDBIndex -> Maybe IDBKeyRange -> m IDBRequest
 getKeyRangeUnchecked self key
@@ -240,6 +329,14 @@
 getKey_ self key = liftIO (void (js_getKey (self) key))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/IDBIndex.getKey Mozilla IDBIndex.getKey documentation> 
+getKeyUnsafe ::
+             (MonadIO m, HasCallStack) => IDBIndex -> JSVal -> m IDBRequest
+getKeyUnsafe self key
+  = liftIO
+      ((nullableToMaybe <$> (js_getKey (self) key)) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/IDBIndex.getKey Mozilla IDBIndex.getKey documentation> 
 getKeyUnchecked :: (MonadIO m) => IDBIndex -> JSVal -> m IDBRequest
 getKeyUnchecked self key
   = liftIO (fromJust . nullableToMaybe <$> (js_getKey (self) key))
@@ -262,6 +359,16 @@
   = liftIO (void (js_countRange (self) (maybeToNullable range)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/IDBIndex.count Mozilla IDBIndex.count documentation> 
+countRangeUnsafe ::
+                 (MonadIO m, HasCallStack) =>
+                   IDBIndex -> Maybe IDBKeyRange -> m IDBRequest
+countRangeUnsafe self range
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_countRange (self) (maybeToNullable range)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/IDBIndex.count Mozilla IDBIndex.count documentation> 
 countRangeUnchecked ::
                     (MonadIO m) => IDBIndex -> Maybe IDBKeyRange -> m IDBRequest
 countRangeUnchecked self range
@@ -281,6 +388,14 @@
 count_ self key = liftIO (void (js_count (self) key))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/IDBIndex.count Mozilla IDBIndex.count documentation> 
+countUnsafe ::
+            (MonadIO m, HasCallStack) => IDBIndex -> JSVal -> m IDBRequest
+countUnsafe self key
+  = liftIO
+      ((nullableToMaybe <$> (js_count (self) key)) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/IDBIndex.count Mozilla IDBIndex.count documentation> 
 countUnchecked :: (MonadIO m) => IDBIndex -> JSVal -> m IDBRequest
 countUnchecked self key
   = liftIO (fromJust . nullableToMaybe <$> (js_count (self) key))
@@ -302,6 +417,14 @@
   = liftIO (nullableToMaybe <$> (js_getObjectStore (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/IDBIndex.objectStore Mozilla IDBIndex.objectStore documentation> 
+getObjectStoreUnsafe ::
+                     (MonadIO m, HasCallStack) => IDBIndex -> m IDBObjectStore
+getObjectStoreUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getObjectStore (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/IDBIndex.objectStore Mozilla IDBIndex.objectStore documentation> 
 getObjectStoreUnchecked ::
                         (MonadIO m) => IDBIndex -> m IDBObjectStore
 getObjectStoreUnchecked self
@@ -315,6 +438,14 @@
 getKeyPath :: (MonadIO m) => IDBIndex -> m (Maybe IDBAny)
 getKeyPath self
   = liftIO (nullableToMaybe <$> (js_getKeyPath (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/IDBIndex.keyPath Mozilla IDBIndex.keyPath documentation> 
+getKeyPathUnsafe ::
+                 (MonadIO m, HasCallStack) => IDBIndex -> m IDBAny
+getKeyPathUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getKeyPath (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/IDBIndex.keyPath Mozilla IDBIndex.keyPath documentation> 
 getKeyPathUnchecked :: (MonadIO m) => IDBIndex -> m IDBAny
diff --git a/src/GHCJS/DOM/JSFFI/Generated/IDBKeyRange.hs b/src/GHCJS/DOM/JSFFI/Generated/IDBKeyRange.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/IDBKeyRange.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/IDBKeyRange.hs
@@ -1,13 +1,20 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.IDBKeyRange
-       (js_only, only, only_, onlyUnchecked, js_lowerBound, lowerBound,
-        lowerBound_, lowerBoundUnchecked, js_upperBound, upperBound,
-        upperBound_, upperBoundUnchecked, js_bound, bound, bound_,
+       (js_only, only, only_, onlyUnsafe, onlyUnchecked, js_lowerBound,
+        lowerBound, lowerBound_, lowerBoundUnsafe, lowerBoundUnchecked,
+        js_upperBound, upperBound, upperBound_, upperBoundUnsafe,
+        upperBoundUnchecked, js_bound, bound, bound_, boundUnsafe,
         boundUnchecked, js_getLower, getLower, js_getUpper, getUpper,
         js_getLowerOpen, getLowerOpen, js_getUpperOpen, getUpperOpen,
-        IDBKeyRange, castToIDBKeyRange, gTypeIDBKeyRange)
+        IDBKeyRange(..), gTypeIDBKeyRange)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -23,6 +30,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"only\"]($2)" js_only ::
         IDBKeyRange -> JSVal -> IO (Nullable IDBKeyRange)
@@ -38,6 +55,14 @@
 only_ self value = liftIO (void (js_only (self) value))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/IDBKeyRange.only Mozilla IDBKeyRange.only documentation> 
+onlyUnsafe ::
+           (MonadIO m, HasCallStack) => IDBKeyRange -> JSVal -> m IDBKeyRange
+onlyUnsafe self value
+  = liftIO
+      ((nullableToMaybe <$> (js_only (self) value)) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/IDBKeyRange.only Mozilla IDBKeyRange.only documentation> 
 onlyUnchecked ::
               (MonadIO m) => IDBKeyRange -> JSVal -> m IDBKeyRange
 onlyUnchecked self value
@@ -60,6 +85,15 @@
   = liftIO (void (js_lowerBound (self) lower open))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/IDBKeyRange.lowerBound Mozilla IDBKeyRange.lowerBound documentation> 
+lowerBoundUnsafe ::
+                 (MonadIO m, HasCallStack) =>
+                   IDBKeyRange -> JSVal -> Bool -> m IDBKeyRange
+lowerBoundUnsafe self lower open
+  = liftIO
+      ((nullableToMaybe <$> (js_lowerBound (self) lower open)) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/IDBKeyRange.lowerBound Mozilla IDBKeyRange.lowerBound documentation> 
 lowerBoundUnchecked ::
                     (MonadIO m) => IDBKeyRange -> JSVal -> Bool -> m IDBKeyRange
 lowerBoundUnchecked self lower open
@@ -83,6 +117,15 @@
   = liftIO (void (js_upperBound (self) upper open))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/IDBKeyRange.upperBound Mozilla IDBKeyRange.upperBound documentation> 
+upperBoundUnsafe ::
+                 (MonadIO m, HasCallStack) =>
+                   IDBKeyRange -> JSVal -> Bool -> m IDBKeyRange
+upperBoundUnsafe self upper open
+  = liftIO
+      ((nullableToMaybe <$> (js_upperBound (self) upper open)) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/IDBKeyRange.upperBound Mozilla IDBKeyRange.upperBound documentation> 
 upperBoundUnchecked ::
                     (MonadIO m) => IDBKeyRange -> JSVal -> Bool -> m IDBKeyRange
 upperBoundUnchecked self upper open
@@ -110,6 +153,16 @@
          IDBKeyRange -> JSVal -> JSVal -> Bool -> Bool -> m ()
 bound_ self lower upper lowerOpen upperOpen
   = liftIO (void (js_bound (self) lower upper lowerOpen upperOpen))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/IDBKeyRange.bound Mozilla IDBKeyRange.bound documentation> 
+boundUnsafe ::
+            (MonadIO m, HasCallStack) =>
+              IDBKeyRange -> JSVal -> JSVal -> Bool -> Bool -> m IDBKeyRange
+boundUnsafe self lower upper lowerOpen upperOpen
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_bound (self) lower upper lowerOpen upperOpen))
+         >>= maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/IDBKeyRange.bound Mozilla IDBKeyRange.bound documentation> 
 boundUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/IDBObjectStore.hs b/src/GHCJS/DOM/JSFFI/Generated/IDBObjectStore.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/IDBObjectStore.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/IDBObjectStore.hs
@@ -1,25 +1,35 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.IDBObjectStore
-       (js_put, put, put_, putUnchecked, js_add, add, add_, addUnchecked,
-        js_deleteRange, deleteRange, deleteRange_, deleteRangeUnchecked,
-        js_delete, delete, delete_, deleteUnchecked, js_getRange, getRange,
-        getRange_, getRangeUnchecked, js_get, get, get_, getUnchecked,
-        js_clear, clear, clear_, clearUnchecked, js_openCursorRange,
-        openCursorRange, openCursorRange_, openCursorRangeUnchecked,
-        js_openCursor, openCursor, openCursor_, openCursorUnchecked,
-        js_createIndex', createIndex', createIndex'_,
-        createIndex'Unchecked, js_createIndex, createIndex, createIndex_,
-        createIndexUnchecked, js_index, index, index_, indexUnchecked,
+       (js_put, put, put_, putUnsafe, putUnchecked, js_add, add, add_,
+        addUnsafe, addUnchecked, js_deleteRange, deleteRange, deleteRange_,
+        deleteRangeUnsafe, deleteRangeUnchecked, js_delete, delete,
+        delete_, deleteUnsafe, deleteUnchecked, js_getRange, getRange,
+        getRange_, getRangeUnsafe, getRangeUnchecked, js_get, get, get_,
+        getUnsafe, getUnchecked, js_clear, clear, clear_, clearUnsafe,
+        clearUnchecked, js_openCursorRange, openCursorRange,
+        openCursorRange_, openCursorRangeUnsafe, openCursorRangeUnchecked,
+        js_openCursor, openCursor, openCursor_, openCursorUnsafe,
+        openCursorUnchecked, js_createIndex', createIndex', createIndex'_,
+        createIndex'Unsafe, createIndex'Unchecked, js_createIndex,
+        createIndex, createIndex_, createIndexUnsafe, createIndexUnchecked,
+        js_index, index, index_, indexUnsafe, indexUnchecked,
         js_deleteIndex, deleteIndex, js_countRange, countRange,
-        countRange_, countRangeUnchecked, js_count, count, count_,
-        countUnchecked, js_getName, getName, getNameUnchecked,
-        js_getKeyPath, getKeyPath, getKeyPathUnchecked, js_getIndexNames,
-        getIndexNames, getIndexNamesUnchecked, js_getTransaction,
-        getTransaction, getTransactionUnchecked, js_getAutoIncrement,
-        getAutoIncrement, IDBObjectStore, castToIDBObjectStore,
-        gTypeIDBObjectStore)
+        countRange_, countRangeUnsafe, countRangeUnchecked, js_count,
+        count, count_, countUnsafe, countUnchecked, js_getName, getName,
+        getNameUnsafe, getNameUnchecked, js_getKeyPath, getKeyPath,
+        getKeyPathUnsafe, getKeyPathUnchecked, js_getIndexNames,
+        getIndexNames, getIndexNamesUnsafe, getIndexNamesUnchecked,
+        js_getTransaction, getTransaction, getTransactionUnsafe,
+        getTransactionUnchecked, js_getAutoIncrement, getAutoIncrement,
+        IDBObjectStore(..), gTypeIDBObjectStore)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -35,6 +45,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"put\"]($2, $3)" js_put ::
         IDBObjectStore -> JSVal -> JSVal -> IO (Nullable IDBRequest)
@@ -51,6 +71,15 @@
 put_ self value key = liftIO (void (js_put (self) value key))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/IDBObjectStore.put Mozilla IDBObjectStore.put documentation> 
+putUnsafe ::
+          (MonadIO m, HasCallStack) =>
+            IDBObjectStore -> JSVal -> JSVal -> m IDBRequest
+putUnsafe self value key
+  = liftIO
+      ((nullableToMaybe <$> (js_put (self) value key)) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/IDBObjectStore.put Mozilla IDBObjectStore.put documentation> 
 putUnchecked ::
              (MonadIO m) => IDBObjectStore -> JSVal -> JSVal -> m IDBRequest
 putUnchecked self value key
@@ -71,6 +100,15 @@
 add_ self value key = liftIO (void (js_add (self) value key))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/IDBObjectStore.add Mozilla IDBObjectStore.add documentation> 
+addUnsafe ::
+          (MonadIO m, HasCallStack) =>
+            IDBObjectStore -> JSVal -> JSVal -> m IDBRequest
+addUnsafe self value key
+  = liftIO
+      ((nullableToMaybe <$> (js_add (self) value key)) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/IDBObjectStore.add Mozilla IDBObjectStore.add documentation> 
 addUnchecked ::
              (MonadIO m) => IDBObjectStore -> JSVal -> JSVal -> m IDBRequest
 addUnchecked self value key
@@ -96,6 +134,16 @@
   = liftIO (void (js_deleteRange (self) (maybeToNullable keyRange)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/IDBObjectStore.delete Mozilla IDBObjectStore.delete documentation> 
+deleteRangeUnsafe ::
+                  (MonadIO m, HasCallStack) =>
+                    IDBObjectStore -> Maybe IDBKeyRange -> m IDBRequest
+deleteRangeUnsafe self keyRange
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_deleteRange (self) (maybeToNullable keyRange)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/IDBObjectStore.delete Mozilla IDBObjectStore.delete documentation> 
 deleteRangeUnchecked ::
                      (MonadIO m) => IDBObjectStore -> Maybe IDBKeyRange -> m IDBRequest
 deleteRangeUnchecked self keyRange
@@ -117,6 +165,15 @@
 delete_ self key = liftIO (void (js_delete (self) key))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/IDBObjectStore.delete Mozilla IDBObjectStore.delete documentation> 
+deleteUnsafe ::
+             (MonadIO m, HasCallStack) =>
+               IDBObjectStore -> JSVal -> m IDBRequest
+deleteUnsafe self key
+  = liftIO
+      ((nullableToMaybe <$> (js_delete (self) key)) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/IDBObjectStore.delete Mozilla IDBObjectStore.delete documentation> 
 deleteUnchecked ::
                 (MonadIO m) => IDBObjectStore -> JSVal -> m IDBRequest
 deleteUnchecked self key
@@ -140,6 +197,15 @@
   = liftIO (void (js_getRange (self) (maybeToNullable key)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/IDBObjectStore.get Mozilla IDBObjectStore.get documentation> 
+getRangeUnsafe ::
+               (MonadIO m, HasCallStack) =>
+                 IDBObjectStore -> Maybe IDBKeyRange -> m IDBRequest
+getRangeUnsafe self key
+  = liftIO
+      ((nullableToMaybe <$> (js_getRange (self) (maybeToNullable key)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/IDBObjectStore.get Mozilla IDBObjectStore.get documentation> 
 getRangeUnchecked ::
                   (MonadIO m) => IDBObjectStore -> Maybe IDBKeyRange -> m IDBRequest
 getRangeUnchecked self key
@@ -160,6 +226,15 @@
 get_ self key = liftIO (void (js_get (self) key))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/IDBObjectStore.get Mozilla IDBObjectStore.get documentation> 
+getUnsafe ::
+          (MonadIO m, HasCallStack) =>
+            IDBObjectStore -> JSVal -> m IDBRequest
+getUnsafe self key
+  = liftIO
+      ((nullableToMaybe <$> (js_get (self) key)) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/IDBObjectStore.get Mozilla IDBObjectStore.get documentation> 
 getUnchecked ::
              (MonadIO m) => IDBObjectStore -> JSVal -> m IDBRequest
 getUnchecked self key
@@ -177,6 +252,14 @@
 clear_ self = liftIO (void (js_clear (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/IDBObjectStore.clear Mozilla IDBObjectStore.clear documentation> 
+clearUnsafe ::
+            (MonadIO m, HasCallStack) => IDBObjectStore -> m IDBRequest
+clearUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_clear (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/IDBObjectStore.clear Mozilla IDBObjectStore.clear documentation> 
 clearUnchecked :: (MonadIO m) => IDBObjectStore -> m IDBRequest
 clearUnchecked self
   = liftIO (fromJust . nullableToMaybe <$> (js_clear (self)))
@@ -208,6 +291,17 @@
             (toJSString direction)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/IDBObjectStore.openCursor Mozilla IDBObjectStore.openCursor documentation> 
+openCursorRangeUnsafe ::
+                      (MonadIO m, ToJSString direction, HasCallStack) =>
+                        IDBObjectStore -> Maybe IDBKeyRange -> direction -> m IDBRequest
+openCursorRangeUnsafe self range direction
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_openCursorRange (self) (maybeToNullable range)
+             (toJSString direction)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/IDBObjectStore.openCursor Mozilla IDBObjectStore.openCursor documentation> 
 openCursorRangeUnchecked ::
                          (MonadIO m, ToJSString direction) =>
                            IDBObjectStore -> Maybe IDBKeyRange -> direction -> m IDBRequest
@@ -238,6 +332,16 @@
   = liftIO (void (js_openCursor (self) key (toJSString direction)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/IDBObjectStore.openCursor Mozilla IDBObjectStore.openCursor documentation> 
+openCursorUnsafe ::
+                 (MonadIO m, ToJSString direction, HasCallStack) =>
+                   IDBObjectStore -> JSVal -> direction -> m IDBRequest
+openCursorUnsafe self key direction
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_openCursor (self) key (toJSString direction)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/IDBObjectStore.openCursor Mozilla IDBObjectStore.openCursor documentation> 
 openCursorUnchecked ::
                     (MonadIO m, ToJSString direction) =>
                       IDBObjectStore -> JSVal -> direction -> m IDBRequest
@@ -277,6 +381,19 @@
             (maybeToNullable (fmap toDictionary options))))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/IDBObjectStore.createIndex Mozilla IDBObjectStore.createIndex documentation> 
+createIndex'Unsafe ::
+                   (MonadIO m, ToJSString name, ToJSString keyPath,
+                    IsDictionary options, HasCallStack) =>
+                     IDBObjectStore -> name -> [keyPath] -> Maybe options -> m IDBIndex
+createIndex'Unsafe self name keyPath options
+  = liftIO
+      ((nullableToMaybe <$>
+          (toJSVal keyPath >>=
+             \ keyPath' -> js_createIndex' (self) (toJSString name) keyPath'
+             (maybeToNullable (fmap toDictionary options))))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/IDBObjectStore.createIndex Mozilla IDBObjectStore.createIndex documentation> 
 createIndex'Unchecked ::
                       (MonadIO m, ToJSString name, ToJSString keyPath,
                        IsDictionary options) =>
@@ -318,6 +435,18 @@
             (maybeToNullable (fmap toDictionary options))))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/IDBObjectStore.createIndex Mozilla IDBObjectStore.createIndex documentation> 
+createIndexUnsafe ::
+                  (MonadIO m, ToJSString name, ToJSString keyPath,
+                   IsDictionary options, HasCallStack) =>
+                    IDBObjectStore -> name -> keyPath -> Maybe options -> m IDBIndex
+createIndexUnsafe self name keyPath options
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_createIndex (self) (toJSString name) (toJSString keyPath)
+             (maybeToNullable (fmap toDictionary options))))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/IDBObjectStore.createIndex Mozilla IDBObjectStore.createIndex documentation> 
 createIndexUnchecked ::
                      (MonadIO m, ToJSString name, ToJSString keyPath,
                       IsDictionary options) =>
@@ -345,6 +474,15 @@
   = liftIO (void (js_index (self) (toJSString name)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/IDBObjectStore.index Mozilla IDBObjectStore.index documentation> 
+indexUnsafe ::
+            (MonadIO m, ToJSString name, HasCallStack) =>
+              IDBObjectStore -> name -> m IDBIndex
+indexUnsafe self name
+  = liftIO
+      ((nullableToMaybe <$> (js_index (self) (toJSString name))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/IDBObjectStore.index Mozilla IDBObjectStore.index documentation> 
 indexUnchecked ::
                (MonadIO m, ToJSString name) =>
                  IDBObjectStore -> name -> m IDBIndex
@@ -382,6 +520,16 @@
   = liftIO (void (js_countRange (self) (maybeToNullable range)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/IDBObjectStore.count Mozilla IDBObjectStore.count documentation> 
+countRangeUnsafe ::
+                 (MonadIO m, HasCallStack) =>
+                   IDBObjectStore -> Maybe IDBKeyRange -> m IDBRequest
+countRangeUnsafe self range
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_countRange (self) (maybeToNullable range)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/IDBObjectStore.count Mozilla IDBObjectStore.count documentation> 
 countRangeUnchecked ::
                     (MonadIO m) => IDBObjectStore -> Maybe IDBKeyRange -> m IDBRequest
 countRangeUnchecked self range
@@ -402,6 +550,15 @@
 count_ self key = liftIO (void (js_count (self) key))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/IDBObjectStore.count Mozilla IDBObjectStore.count documentation> 
+countUnsafe ::
+            (MonadIO m, HasCallStack) =>
+              IDBObjectStore -> JSVal -> m IDBRequest
+countUnsafe self key
+  = liftIO
+      ((nullableToMaybe <$> (js_count (self) key)) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/IDBObjectStore.count Mozilla IDBObjectStore.count documentation> 
 countUnchecked ::
                (MonadIO m) => IDBObjectStore -> JSVal -> m IDBRequest
 countUnchecked self key
@@ -417,6 +574,15 @@
 getName self = liftIO (fromMaybeJSString <$> (js_getName (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/IDBObjectStore.name Mozilla IDBObjectStore.name documentation> 
+getNameUnsafe ::
+              (MonadIO m, HasCallStack, FromJSString result) =>
+                IDBObjectStore -> m result
+getNameUnsafe self
+  = liftIO
+      ((fromMaybeJSString <$> (js_getName (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/IDBObjectStore.name Mozilla IDBObjectStore.name documentation> 
 getNameUnchecked ::
                  (MonadIO m, FromJSString result) => IDBObjectStore -> m result
 getNameUnchecked self
@@ -431,6 +597,14 @@
   = liftIO (nullableToMaybe <$> (js_getKeyPath (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/IDBObjectStore.keyPath Mozilla IDBObjectStore.keyPath documentation> 
+getKeyPathUnsafe ::
+                 (MonadIO m, HasCallStack) => IDBObjectStore -> m IDBAny
+getKeyPathUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getKeyPath (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/IDBObjectStore.keyPath Mozilla IDBObjectStore.keyPath documentation> 
 getKeyPathUnchecked :: (MonadIO m) => IDBObjectStore -> m IDBAny
 getKeyPathUnchecked self
   = liftIO (fromJust . nullableToMaybe <$> (js_getKeyPath (self)))
@@ -445,6 +619,14 @@
   = liftIO (nullableToMaybe <$> (js_getIndexNames (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/IDBObjectStore.indexNames Mozilla IDBObjectStore.indexNames documentation> 
+getIndexNamesUnsafe ::
+                    (MonadIO m, HasCallStack) => IDBObjectStore -> m DOMStringList
+getIndexNamesUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getIndexNames (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/IDBObjectStore.indexNames Mozilla IDBObjectStore.indexNames documentation> 
 getIndexNamesUnchecked ::
                        (MonadIO m) => IDBObjectStore -> m DOMStringList
 getIndexNamesUnchecked self
@@ -458,6 +640,14 @@
                (MonadIO m) => IDBObjectStore -> m (Maybe IDBTransaction)
 getTransaction self
   = liftIO (nullableToMaybe <$> (js_getTransaction (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/IDBObjectStore.transaction Mozilla IDBObjectStore.transaction documentation> 
+getTransactionUnsafe ::
+                     (MonadIO m, HasCallStack) => IDBObjectStore -> m IDBTransaction
+getTransactionUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getTransaction (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/IDBObjectStore.transaction Mozilla IDBObjectStore.transaction documentation> 
 getTransactionUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/IDBOpenDBRequest.hs b/src/GHCJS/DOM/JSFFI/Generated/IDBOpenDBRequest.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/IDBOpenDBRequest.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/IDBOpenDBRequest.hs
@@ -1,9 +1,15 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.IDBOpenDBRequest
-       (blocked, upgradeNeeded, IDBOpenDBRequest, castToIDBOpenDBRequest,
+       (blocked, upgradeNeeded, IDBOpenDBRequest(..),
         gTypeIDBOpenDBRequest)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -19,6 +25,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/IDBOpenDBRequest.onblocked Mozilla IDBOpenDBRequest.onblocked documentation> 
 blocked :: EventName IDBOpenDBRequest IDBVersionChangeEvent
diff --git a/src/GHCJS/DOM/JSFFI/Generated/IDBRequest.hs b/src/GHCJS/DOM/JSFFI/Generated/IDBRequest.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/IDBRequest.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/IDBRequest.hs
@@ -1,13 +1,19 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.IDBRequest
-       (js_getResult, getResult, getResultUnchecked, js_getError,
-        getError, getErrorUnchecked, js_getSource, getSource,
-        getSourceUnchecked, js_getTransaction, getTransaction,
+       (js_getResult, getResult, getResultUnsafe, getResultUnchecked,
+        js_getError, getError, getErrorUnsafe, getErrorUnchecked,
+        js_getSource, getSource, getSourceUnsafe, getSourceUnchecked,
+        js_getTransaction, getTransaction, getTransactionUnsafe,
         getTransactionUnchecked, js_getReadyState, getReadyState, success,
-        error, IDBRequest, castToIDBRequest, gTypeIDBRequest, IsIDBRequest,
-        toIDBRequest)
+        error, IDBRequest(..), gTypeIDBRequest, IsIDBRequest, toIDBRequest)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -23,6 +29,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"result\"]" js_getResult ::
         IDBRequest -> IO (Nullable IDBAny)
@@ -34,6 +50,14 @@
   = liftIO (nullableToMaybe <$> (js_getResult (toIDBRequest self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/IDBRequest.result Mozilla IDBRequest.result documentation> 
+getResultUnsafe ::
+                (MonadIO m, IsIDBRequest self, HasCallStack) => self -> m IDBAny
+getResultUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getResult (toIDBRequest self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/IDBRequest.result Mozilla IDBRequest.result documentation> 
 getResultUnchecked ::
                    (MonadIO m, IsIDBRequest self) => self -> m IDBAny
 getResultUnchecked self
@@ -50,6 +74,14 @@
   = liftIO (nullableToMaybe <$> (js_getError (toIDBRequest self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/IDBRequest.error Mozilla IDBRequest.error documentation> 
+getErrorUnsafe ::
+               (MonadIO m, IsIDBRequest self, HasCallStack) => self -> m DOMError
+getErrorUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getError (toIDBRequest self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/IDBRequest.error Mozilla IDBRequest.error documentation> 
 getErrorUnchecked ::
                   (MonadIO m, IsIDBRequest self) => self -> m DOMError
 getErrorUnchecked self
@@ -66,6 +98,14 @@
   = liftIO (nullableToMaybe <$> (js_getSource (toIDBRequest self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/IDBRequest.source Mozilla IDBRequest.source documentation> 
+getSourceUnsafe ::
+                (MonadIO m, IsIDBRequest self, HasCallStack) => self -> m IDBAny
+getSourceUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getSource (toIDBRequest self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/IDBRequest.source Mozilla IDBRequest.source documentation> 
 getSourceUnchecked ::
                    (MonadIO m, IsIDBRequest self) => self -> m IDBAny
 getSourceUnchecked self
@@ -81,6 +121,15 @@
 getTransaction self
   = liftIO
       (nullableToMaybe <$> (js_getTransaction (toIDBRequest self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/IDBRequest.transaction Mozilla IDBRequest.transaction documentation> 
+getTransactionUnsafe ::
+                     (MonadIO m, IsIDBRequest self, HasCallStack) =>
+                       self -> m IDBTransaction
+getTransactionUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getTransaction (toIDBRequest self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/IDBRequest.transaction Mozilla IDBRequest.transaction documentation> 
 getTransactionUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/IDBTransaction.hs b/src/GHCJS/DOM/JSFFI/Generated/IDBTransaction.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/IDBTransaction.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/IDBTransaction.hs
@@ -1,12 +1,18 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.IDBTransaction
-       (js_objectStore, objectStore, objectStore_, objectStoreUnchecked,
-        js_abort, abort, js_getMode, getMode, js_getDb, getDb,
-        getDbUnchecked, js_getError, getError, getErrorUnchecked,
-        abortEvent, complete, error, IDBTransaction, castToIDBTransaction,
-        gTypeIDBTransaction)
+       (js_objectStore, objectStore, objectStore_, objectStoreUnsafe,
+        objectStoreUnchecked, js_abort, abort, js_getMode, getMode,
+        js_getDb, getDb, getDbUnsafe, getDbUnchecked, js_getError,
+        getError, getErrorUnsafe, getErrorUnchecked, abortEvent, complete,
+        error, IDBTransaction(..), gTypeIDBTransaction)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -22,6 +28,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"objectStore\"]($2)"
         js_objectStore ::
@@ -42,6 +58,15 @@
   = liftIO (void (js_objectStore (self) (toJSString name)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/IDBTransaction.objectStore Mozilla IDBTransaction.objectStore documentation> 
+objectStoreUnsafe ::
+                  (MonadIO m, ToJSString name, HasCallStack) =>
+                    IDBTransaction -> name -> m IDBObjectStore
+objectStoreUnsafe self name
+  = liftIO
+      ((nullableToMaybe <$> (js_objectStore (self) (toJSString name)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/IDBTransaction.objectStore Mozilla IDBTransaction.objectStore documentation> 
 objectStoreUnchecked ::
                      (MonadIO m, ToJSString name) =>
                        IDBTransaction -> name -> m IDBObjectStore
@@ -73,6 +98,14 @@
 getDb self = liftIO (nullableToMaybe <$> (js_getDb (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/IDBTransaction.db Mozilla IDBTransaction.db documentation> 
+getDbUnsafe ::
+            (MonadIO m, HasCallStack) => IDBTransaction -> m IDBDatabase
+getDbUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getDb (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/IDBTransaction.db Mozilla IDBTransaction.db documentation> 
 getDbUnchecked :: (MonadIO m) => IDBTransaction -> m IDBDatabase
 getDbUnchecked self
   = liftIO (fromJust . nullableToMaybe <$> (js_getDb (self)))
@@ -83,6 +116,14 @@
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/IDBTransaction.error Mozilla IDBTransaction.error documentation> 
 getError :: (MonadIO m) => IDBTransaction -> m (Maybe DOMError)
 getError self = liftIO (nullableToMaybe <$> (js_getError (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/IDBTransaction.error Mozilla IDBTransaction.error documentation> 
+getErrorUnsafe ::
+               (MonadIO m, HasCallStack) => IDBTransaction -> m DOMError
+getErrorUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getError (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/IDBTransaction.error Mozilla IDBTransaction.error documentation> 
 getErrorUnchecked :: (MonadIO m) => IDBTransaction -> m DOMError
diff --git a/src/GHCJS/DOM/JSFFI/Generated/IDBVersionChangeEvent.hs b/src/GHCJS/DOM/JSFFI/Generated/IDBVersionChangeEvent.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/IDBVersionChangeEvent.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/IDBVersionChangeEvent.hs
@@ -1,10 +1,16 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.IDBVersionChangeEvent
        (js_getOldVersion, getOldVersion, js_getNewVersion, getNewVersion,
-        getNewVersionUnchecked, IDBVersionChangeEvent,
-        castToIDBVersionChangeEvent, gTypeIDBVersionChangeEvent)
+        getNewVersionUnsafe, getNewVersionUnchecked,
+        IDBVersionChangeEvent(..), gTypeIDBVersionChangeEvent)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -20,6 +26,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"oldVersion\"]"
         js_getOldVersion :: IDBVersionChangeEvent -> IO Double
@@ -37,6 +53,14 @@
 getNewVersion self
   = liftIO
       (fmap round . nullableToMaybe <$> (js_getNewVersion (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/IDBVersionChangeEvent.newVersion Mozilla IDBVersionChangeEvent.newVersion documentation> 
+getNewVersionUnsafe ::
+                    (MonadIO m, HasCallStack) => IDBVersionChangeEvent -> m Word64
+getNewVersionUnsafe self
+  = liftIO
+      ((fmap round . nullableToMaybe <$> (js_getNewVersion (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/IDBVersionChangeEvent.newVersion Mozilla IDBVersionChangeEvent.newVersion documentation> 
 getNewVersionUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/ImageData.hs b/src/GHCJS/DOM/JSFFI/Generated/ImageData.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/ImageData.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/ImageData.hs
@@ -1,10 +1,16 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.ImageData
        (js_newImageData, newImageData, js_newImageData', newImageData',
-        js_getWidth, getWidth, js_getHeight, getHeight, ImageData,
-        castToImageData, gTypeImageData)
+        js_getWidth, getWidth, js_getHeight, getHeight, ImageData(..),
+        gTypeImageData)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -20,6 +26,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe
         "new window[\"ImageData\"]($1, $2,\n$3)" js_newImageData ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/InspectorFrontendHost.hs b/src/GHCJS/DOM/JSFFI/Generated/InspectorFrontendHost.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/InspectorFrontendHost.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/InspectorFrontendHost.hs
@@ -1,4 +1,9 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.InspectorFrontendHost
        (js_loaded, loaded, js_closeWindow, closeWindow, js_bringToFront,
         bringToFront, js_setZoomFactor, setZoomFactor,
@@ -17,10 +22,11 @@
         sendMessageToBackend, js_unbufferedLog, unbufferedLog,
         js_isUnderTest, isUnderTest, isUnderTest_, js_beep, beep,
         js_canInspectWorkers, canInspectWorkers, canInspectWorkers_,
-        js_canSaveAs, canSaveAs, canSaveAs_, InspectorFrontendHost,
-        castToInspectorFrontendHost, gTypeInspectorFrontendHost)
+        js_canSaveAs, canSaveAs, canSaveAs_, InspectorFrontendHost(..),
+        gTypeInspectorFrontendHost)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -36,6 +42,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"loaded\"]()" js_loaded ::
         InspectorFrontendHost -> IO ()
diff --git a/src/GHCJS/DOM/JSFFI/Generated/InternalSettings.hs b/src/GHCJS/DOM/JSFFI/Generated/InternalSettings.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/InternalSettings.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/InternalSettings.hs
@@ -1,4 +1,9 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.InternalSettings
        (js_setTouchEventEmulationEnabled, setTouchEventEmulationEnabled,
         js_setStandardFontFamily, setStandardFontFamily,
@@ -37,9 +42,10 @@
         setBackgroundShouldExtendBeyondPage,
         js_setScrollingTreeIncludesFrames, setScrollingTreeIncludesFrames,
         js_setMinimumTimerInterval, setMinimumTimerInterval,
-        InternalSettings, castToInternalSettings, gTypeInternalSettings)
+        InternalSettings(..), gTypeInternalSettings)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -55,6 +61,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe
         "$1[\"setTouchEventEmulationEnabled\"]($2)"
diff --git a/src/GHCJS/DOM/JSFFI/Generated/Internals.hs b/src/GHCJS/DOM/JSFFI/Generated/Internals.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/Internals.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/Internals.hs
@@ -1,4 +1,9 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.Internals
        (js_address, address, address_, js_nodeNeedsStyleRecalc,
         nodeNeedsStyleRecalc, nodeNeedsStyleRecalc_, js_description,
@@ -16,17 +21,20 @@
         js_computedStyleIncludingVisitedInfo,
         computedStyleIncludingVisitedInfo,
         computedStyleIncludingVisitedInfo_,
+        computedStyleIncludingVisitedInfoUnsafe,
         computedStyleIncludingVisitedInfoUnchecked, js_ensureShadowRoot,
-        ensureShadowRoot, ensureShadowRoot_, ensureShadowRootUnchecked,
-        js_createShadowRoot, createShadowRoot, createShadowRoot_,
+        ensureShadowRoot, ensureShadowRoot_, ensureShadowRootUnsafe,
+        ensureShadowRootUnchecked, js_createShadowRoot, createShadowRoot,
+        createShadowRoot_, createShadowRootUnsafe,
         createShadowRootUnchecked, js_shadowRoot, shadowRoot, shadowRoot_,
-        shadowRootUnchecked, js_shadowRootType, shadowRootType,
-        shadowRootType_, js_includerFor, includerFor, includerFor_,
-        includerForUnchecked, js_shadowPseudoId, shadowPseudoId,
-        shadowPseudoId_, js_setShadowPseudoId, setShadowPseudoId,
-        js_treeScopeRootNode, treeScopeRootNode, treeScopeRootNode_,
+        shadowRootUnsafe, shadowRootUnchecked, js_shadowRootType,
+        shadowRootType, shadowRootType_, js_includerFor, includerFor,
+        includerFor_, includerForUnsafe, includerForUnchecked,
+        js_shadowPseudoId, shadowPseudoId, shadowPseudoId_,
+        js_setShadowPseudoId, setShadowPseudoId, js_treeScopeRootNode,
+        treeScopeRootNode, treeScopeRootNode_, treeScopeRootNodeUnsafe,
         treeScopeRootNodeUnchecked, js_parentTreeScope, parentTreeScope,
-        parentTreeScope_, parentTreeScopeUnchecked,
+        parentTreeScope_, parentTreeScopeUnsafe, parentTreeScopeUnchecked,
         js_lastSpatialNavigationCandidateCount,
         lastSpatialNavigationCandidateCount,
         lastSpatialNavigationCandidateCount_, js_numberOfActiveAnimations,
@@ -53,13 +61,15 @@
         js_setFormControlStateOfPreviousHistoryItem,
         setFormControlStateOfPreviousHistoryItem, js_absoluteCaretBounds,
         absoluteCaretBounds, absoluteCaretBounds_,
-        absoluteCaretBoundsUnchecked, js_boundingBox, boundingBox,
-        boundingBox_, boundingBoxUnchecked, js_inspectorHighlightRects,
+        absoluteCaretBoundsUnsafe, absoluteCaretBoundsUnchecked,
+        js_boundingBox, boundingBox, boundingBox_, boundingBoxUnsafe,
+        boundingBoxUnchecked, js_inspectorHighlightRects,
         inspectorHighlightRects, inspectorHighlightRects_,
-        inspectorHighlightRectsUnchecked, js_inspectorHighlightObject,
-        inspectorHighlightObject, inspectorHighlightObject_,
-        js_markerCountForNode, markerCountForNode, markerCountForNode_,
-        js_markerRangeForNode, markerRangeForNode, markerRangeForNode_,
+        inspectorHighlightRectsUnsafe, inspectorHighlightRectsUnchecked,
+        js_inspectorHighlightObject, inspectorHighlightObject,
+        inspectorHighlightObject_, js_markerCountForNode,
+        markerCountForNode, markerCountForNode_, js_markerRangeForNode,
+        markerRangeForNode, markerRangeForNode_, markerRangeForNodeUnsafe,
         markerRangeForNodeUnchecked, js_markerDescriptionForNode,
         markerDescriptionForNode, markerDescriptionForNode_,
         js_addTextMatchMarker, addTextMatchMarker,
@@ -76,14 +86,15 @@
         countMatchesForText, countMatchesForText_, js_paintControlTints,
         paintControlTints, js_scrollElementToRect, scrollElementToRect,
         js_rangeFromLocationAndLength, rangeFromLocationAndLength,
-        rangeFromLocationAndLength_, rangeFromLocationAndLengthUnchecked,
-        js_locationFromRange, locationFromRange, locationFromRange_,
-        js_lengthFromRange, lengthFromRange, lengthFromRange_,
-        js_rangeAsText, rangeAsText, rangeAsText_, js_subrange, subrange,
-        subrange_, subrangeUnchecked,
-        js_rangeForDictionaryLookupAtLocation,
+        rangeFromLocationAndLength_, rangeFromLocationAndLengthUnsafe,
+        rangeFromLocationAndLengthUnchecked, js_locationFromRange,
+        locationFromRange, locationFromRange_, js_lengthFromRange,
+        lengthFromRange, lengthFromRange_, js_rangeAsText, rangeAsText,
+        rangeAsText_, js_subrange, subrange, subrange_, subrangeUnsafe,
+        subrangeUnchecked, js_rangeForDictionaryLookupAtLocation,
         rangeForDictionaryLookupAtLocation,
         rangeForDictionaryLookupAtLocation_,
+        rangeForDictionaryLookupAtLocationUnsafe,
         rangeForDictionaryLookupAtLocationUnchecked,
         js_setDelegatesScrolling, setDelegatesScrolling,
         js_lastSpellCheckRequestSequence, lastSpellCheckRequestSequence,
@@ -95,13 +106,13 @@
         wheelEventHandlerCount, wheelEventHandlerCount_,
         js_touchEventHandlerCount, touchEventHandlerCount,
         touchEventHandlerCount_, js_nodesFromRect, nodesFromRect,
-        nodesFromRect_, nodesFromRectUnchecked, js_parserMetaData,
-        parserMetaData, parserMetaData_, js_updateEditorUINowIfScheduled,
-        updateEditorUINowIfScheduled, js_hasSpellingMarker,
-        hasSpellingMarker, hasSpellingMarker_, js_hasGrammarMarker,
-        hasGrammarMarker, hasGrammarMarker_, js_hasAutocorrectedMarker,
-        hasAutocorrectedMarker, hasAutocorrectedMarker_,
-        js_setContinuousSpellCheckingEnabled,
+        nodesFromRect_, nodesFromRectUnsafe, nodesFromRectUnchecked,
+        js_parserMetaData, parserMetaData, parserMetaData_,
+        js_updateEditorUINowIfScheduled, updateEditorUINowIfScheduled,
+        js_hasSpellingMarker, hasSpellingMarker, hasSpellingMarker_,
+        js_hasGrammarMarker, hasGrammarMarker, hasGrammarMarker_,
+        js_hasAutocorrectedMarker, hasAutocorrectedMarker,
+        hasAutocorrectedMarker_, js_setContinuousSpellCheckingEnabled,
         setContinuousSpellCheckingEnabled,
         js_setAutomaticQuoteSubstitutionEnabled,
         setAutomaticQuoteSubstitutionEnabled,
@@ -123,8 +134,8 @@
         js_mainThreadScrollingReasons, mainThreadScrollingReasons,
         mainThreadScrollingReasons_, js_nonFastScrollableRects,
         nonFastScrollableRects, nonFastScrollableRects_,
-        nonFastScrollableRectsUnchecked, js_repaintRectsAsText,
-        repaintRectsAsText, repaintRectsAsText_,
+        nonFastScrollableRectsUnsafe, nonFastScrollableRectsUnchecked,
+        js_repaintRectsAsText, repaintRectsAsText, repaintRectsAsText_,
         js_garbageCollectDocumentResources,
         garbageCollectDocumentResources, js_allowRoundingHacks,
         allowRoundingHacks, js_insertAuthorCSS, insertAuthorCSS,
@@ -135,7 +146,8 @@
         numberOfLiveDocuments_, js_consoleMessageArgumentCounts,
         consoleMessageArgumentCounts, consoleMessageArgumentCounts_,
         js_openDummyInspectorFrontend, openDummyInspectorFrontend,
-        openDummyInspectorFrontend_, openDummyInspectorFrontendUnchecked,
+        openDummyInspectorFrontend_, openDummyInspectorFrontendUnsafe,
+        openDummyInspectorFrontendUnchecked,
         js_closeDummyInspectorFrontend, closeDummyInspectorFrontend,
         js_setJavaScriptProfilingEnabled, setJavaScriptProfilingEnabled,
         js_setInspectorIsUnderTest, setInspectorIsUnderTest,
@@ -162,9 +174,10 @@
         js_removeURLSchemeRegisteredAsBypassingContentSecurityPolicy,
         removeURLSchemeRegisteredAsBypassingContentSecurityPolicy,
         js_mallocStatistics, mallocStatistics, mallocStatistics_,
-        mallocStatisticsUnchecked, js_typeConversions, typeConversions,
-        typeConversions_, typeConversionsUnchecked, js_memoryInfo,
-        memoryInfo, memoryInfo_, memoryInfoUnchecked,
+        mallocStatisticsUnsafe, mallocStatisticsUnchecked,
+        js_typeConversions, typeConversions, typeConversions_,
+        typeConversionsUnsafe, typeConversionsUnchecked, js_memoryInfo,
+        memoryInfo, memoryInfo_, memoryInfoUnsafe, memoryInfoUnchecked,
         js_getReferencedFilePaths, getReferencedFilePaths,
         getReferencedFilePaths_, js_startTrackingRepaints,
         startTrackingRepaints, js_stopTrackingRepaints,
@@ -177,8 +190,9 @@
         markerTextForListItem, markerTextForListItem_,
         js_toolTipFromElement, toolTipFromElement, toolTipFromElement_,
         js_deserializeBuffer, deserializeBuffer, deserializeBuffer_,
-        deserializeBufferUnchecked, js_serializeObject, serializeObject,
-        serializeObject_, serializeObjectUnchecked,
+        deserializeBufferUnsafe, deserializeBufferUnchecked,
+        js_serializeObject, serializeObject, serializeObject_,
+        serializeObjectUnsafe, serializeObjectUnchecked,
         js_setUsesOverlayScrollbars, setUsesOverlayScrollbars,
         js_forceReload, forceReload, js_simulateAudioInterruption,
         simulateAudioInterruption, js_mediaElementHasCharacteristic,
@@ -192,42 +206,44 @@
         js_setPrimaryAudioTrackLanguageOverride,
         setPrimaryAudioTrackLanguageOverride, js_setCaptionDisplayMode,
         setCaptionDisplayMode, js_createTimeRanges, createTimeRanges,
-        createTimeRanges_, createTimeRangesUnchecked,
-        js_closestTimeToTimeRanges, closestTimeToTimeRanges,
-        closestTimeToTimeRanges_, js_isSelectPopupVisible,
-        isSelectPopupVisible, isSelectPopupVisible_, js_isVibrating,
-        isVibrating, isVibrating_,
+        createTimeRanges_, createTimeRangesUnsafe,
+        createTimeRangesUnchecked, js_closestTimeToTimeRanges,
+        closestTimeToTimeRanges, closestTimeToTimeRanges_,
+        js_isSelectPopupVisible, isSelectPopupVisible,
+        isSelectPopupVisible_, js_isVibrating, isVibrating, isVibrating_,
         js_isPluginUnavailabilityIndicatorObscured,
         isPluginUnavailabilityIndicatorObscured,
         isPluginUnavailabilityIndicatorObscured_, js_isPluginSnapshotted,
         isPluginSnapshotted, isPluginSnapshotted_, js_selectionBounds,
-        selectionBounds, selectionBounds_, selectionBoundsUnchecked,
-        js_initializeMockMediaSource, initializeMockMediaSource,
-        js_bufferedSamplesForTrackID, bufferedSamplesForTrackID,
-        bufferedSamplesForTrackID_, js_beginMediaSessionInterruption,
-        beginMediaSessionInterruption, js_endMediaSessionInterruption,
-        endMediaSessionInterruption, js_applicationWillEnterForeground,
-        applicationWillEnterForeground, js_applicationWillEnterBackground,
-        applicationWillEnterBackground, js_setMediaSessionRestrictions,
-        setMediaSessionRestrictions, js_postRemoteControlCommand,
-        postRemoteControlCommand, js_simulateSystemSleep,
-        simulateSystemSleep, js_simulateSystemWake, simulateSystemWake,
-        js_elementIsBlockingDisplaySleep, elementIsBlockingDisplaySleep,
-        elementIsBlockingDisplaySleep_, js_installMockPageOverlay,
-        installMockPageOverlay, js_pageOverlayLayerTreeAsText,
-        pageOverlayLayerTreeAsText, pageOverlayLayerTreeAsText_,
-        js_setPageMuted, setPageMuted, js_isPagePlayingAudio,
-        isPagePlayingAudio, isPagePlayingAudio_,
+        selectionBounds, selectionBounds_, selectionBoundsUnsafe,
+        selectionBoundsUnchecked, js_initializeMockMediaSource,
+        initializeMockMediaSource, js_bufferedSamplesForTrackID,
+        bufferedSamplesForTrackID, bufferedSamplesForTrackID_,
+        js_beginMediaSessionInterruption, beginMediaSessionInterruption,
+        js_endMediaSessionInterruption, endMediaSessionInterruption,
+        js_applicationWillEnterForeground, applicationWillEnterForeground,
+        js_applicationWillEnterBackground, applicationWillEnterBackground,
+        js_setMediaSessionRestrictions, setMediaSessionRestrictions,
+        js_postRemoteControlCommand, postRemoteControlCommand,
+        js_simulateSystemSleep, simulateSystemSleep, js_simulateSystemWake,
+        simulateSystemWake, js_elementIsBlockingDisplaySleep,
+        elementIsBlockingDisplaySleep, elementIsBlockingDisplaySleep_,
+        js_installMockPageOverlay, installMockPageOverlay,
+        js_pageOverlayLayerTreeAsText, pageOverlayLayerTreeAsText,
+        pageOverlayLayerTreeAsText_, js_setPageMuted, setPageMuted,
+        js_isPagePlayingAudio, isPagePlayingAudio, isPagePlayingAudio_,
         pattern LAYER_TREE_INCLUDES_VISIBLE_RECTS,
         pattern LAYER_TREE_INCLUDES_TILE_CACHES,
         pattern LAYER_TREE_INCLUDES_REPAINT_RECTS,
         pattern LAYER_TREE_INCLUDES_PAINTING_PHASES,
         pattern LAYER_TREE_INCLUDES_CONTENT_LAYERS, js_getSettings,
-        getSettings, getSettingsUnchecked, js_getWorkerThreadCount,
-        getWorkerThreadCount, js_getConsoleProfiles, getConsoleProfiles,
-        Internals, castToInternals, gTypeInternals)
+        getSettings, getSettingsUnsafe, getSettingsUnchecked,
+        js_getWorkerThreadCount, getWorkerThreadCount,
+        js_getConsoleProfiles, getConsoleProfiles, Internals(..),
+        gTypeInternals)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -243,6 +259,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"address\"]($2)" js_address
         :: Internals -> Nullable Node -> IO JSString
@@ -468,6 +494,17 @@
             (maybeToNullable (fmap toNode node))))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Internals.computedStyleIncludingVisitedInfo Mozilla Internals.computedStyleIncludingVisitedInfo documentation> 
+computedStyleIncludingVisitedInfoUnsafe ::
+                                        (MonadIO m, IsNode node, HasCallStack) =>
+                                          Internals -> Maybe node -> m CSSStyleDeclaration
+computedStyleIncludingVisitedInfoUnsafe self node
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_computedStyleIncludingVisitedInfo (self)
+             (maybeToNullable (fmap toNode node))))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Internals.computedStyleIncludingVisitedInfo Mozilla Internals.computedStyleIncludingVisitedInfo documentation> 
 computedStyleIncludingVisitedInfoUnchecked ::
                                            (MonadIO m, IsNode node) =>
                                              Internals -> Maybe node -> m CSSStyleDeclaration
@@ -501,6 +538,17 @@
             (maybeToNullable (fmap toElement host))))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Internals.ensureShadowRoot Mozilla Internals.ensureShadowRoot documentation> 
+ensureShadowRootUnsafe ::
+                       (MonadIO m, IsElement host, HasCallStack) =>
+                         Internals -> Maybe host -> m Node
+ensureShadowRootUnsafe self host
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_ensureShadowRoot (self)
+             (maybeToNullable (fmap toElement host))))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Internals.ensureShadowRoot Mozilla Internals.ensureShadowRoot documentation> 
 ensureShadowRootUnchecked ::
                           (MonadIO m, IsElement host) => Internals -> Maybe host -> m Node
 ensureShadowRootUnchecked self host
@@ -533,6 +581,17 @@
             (maybeToNullable (fmap toElement host))))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Internals.createShadowRoot Mozilla Internals.createShadowRoot documentation> 
+createShadowRootUnsafe ::
+                       (MonadIO m, IsElement host, HasCallStack) =>
+                         Internals -> Maybe host -> m Node
+createShadowRootUnsafe self host
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_createShadowRoot (self)
+             (maybeToNullable (fmap toElement host))))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Internals.createShadowRoot Mozilla Internals.createShadowRoot documentation> 
 createShadowRootUnchecked ::
                           (MonadIO m, IsElement host) => Internals -> Maybe host -> m Node
 createShadowRootUnchecked self host
@@ -563,6 +622,16 @@
          (js_shadowRoot (self) (maybeToNullable (fmap toElement host))))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Internals.shadowRoot Mozilla Internals.shadowRoot documentation> 
+shadowRootUnsafe ::
+                 (MonadIO m, IsElement host, HasCallStack) =>
+                   Internals -> Maybe host -> m Node
+shadowRootUnsafe self host
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_shadowRoot (self) (maybeToNullable (fmap toElement host))))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Internals.shadowRoot Mozilla Internals.shadowRoot documentation> 
 shadowRootUnchecked ::
                     (MonadIO m, IsElement host) => Internals -> Maybe host -> m Node
 shadowRootUnchecked self host
@@ -611,6 +680,16 @@
       (void (js_includerFor (self) (maybeToNullable (fmap toNode node))))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Internals.includerFor Mozilla Internals.includerFor documentation> 
+includerForUnsafe ::
+                  (MonadIO m, IsNode node, HasCallStack) =>
+                    Internals -> Maybe node -> m Element
+includerForUnsafe self node
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_includerFor (self) (maybeToNullable (fmap toNode node))))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Internals.includerFor Mozilla Internals.includerFor documentation> 
 includerForUnchecked ::
                      (MonadIO m, IsNode node) => Internals -> Maybe node -> m Element
 includerForUnchecked self node
@@ -677,6 +756,16 @@
          (js_treeScopeRootNode (self) (maybeToNullable (fmap toNode node))))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Internals.treeScopeRootNode Mozilla Internals.treeScopeRootNode documentation> 
+treeScopeRootNodeUnsafe ::
+                        (MonadIO m, IsNode node, HasCallStack) =>
+                          Internals -> Maybe node -> m Node
+treeScopeRootNodeUnsafe self node
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_treeScopeRootNode (self) (maybeToNullable (fmap toNode node))))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Internals.treeScopeRootNode Mozilla Internals.treeScopeRootNode documentation> 
 treeScopeRootNodeUnchecked ::
                            (MonadIO m, IsNode node) => Internals -> Maybe node -> m Node
 treeScopeRootNodeUnchecked self node
@@ -706,6 +795,16 @@
          (js_parentTreeScope (self) (maybeToNullable (fmap toNode node))))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Internals.parentTreeScope Mozilla Internals.parentTreeScope documentation> 
+parentTreeScopeUnsafe ::
+                      (MonadIO m, IsNode node, HasCallStack) =>
+                        Internals -> Maybe node -> m Node
+parentTreeScopeUnsafe self node
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_parentTreeScope (self) (maybeToNullable (fmap toNode node))))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Internals.parentTreeScope Mozilla Internals.parentTreeScope documentation> 
 parentTreeScopeUnchecked ::
                          (MonadIO m, IsNode node) => Internals -> Maybe node -> m Node
 parentTreeScopeUnchecked self node
@@ -1002,6 +1101,14 @@
   = liftIO (void (js_absoluteCaretBounds (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Internals.absoluteCaretBounds Mozilla Internals.absoluteCaretBounds documentation> 
+absoluteCaretBoundsUnsafe ::
+                          (MonadIO m, HasCallStack) => Internals -> m ClientRect
+absoluteCaretBoundsUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_absoluteCaretBounds (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Internals.absoluteCaretBounds Mozilla Internals.absoluteCaretBounds documentation> 
 absoluteCaretBoundsUnchecked ::
                              (MonadIO m) => Internals -> m ClientRect
 absoluteCaretBoundsUnchecked self
@@ -1031,6 +1138,16 @@
          (js_boundingBox (self) (maybeToNullable (fmap toElement element))))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Internals.boundingBox Mozilla Internals.boundingBox documentation> 
+boundingBoxUnsafe ::
+                  (MonadIO m, IsElement element, HasCallStack) =>
+                    Internals -> Maybe element -> m ClientRect
+boundingBoxUnsafe self element
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_boundingBox (self) (maybeToNullable (fmap toElement element))))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Internals.boundingBox Mozilla Internals.boundingBox documentation> 
 boundingBoxUnchecked ::
                      (MonadIO m, IsElement element) =>
                        Internals -> Maybe element -> m ClientRect
@@ -1055,6 +1172,14 @@
   = liftIO (void (js_inspectorHighlightRects (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Internals.inspectorHighlightRects Mozilla Internals.inspectorHighlightRects documentation> 
+inspectorHighlightRectsUnsafe ::
+                              (MonadIO m, HasCallStack) => Internals -> m ClientRectList
+inspectorHighlightRectsUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_inspectorHighlightRects (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Internals.inspectorHighlightRects Mozilla Internals.inspectorHighlightRects documentation> 
 inspectorHighlightRectsUnchecked ::
                                  (MonadIO m) => Internals -> m ClientRectList
 inspectorHighlightRectsUnchecked self
@@ -1128,6 +1253,18 @@
             index))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Internals.markerRangeForNode Mozilla Internals.markerRangeForNode documentation> 
+markerRangeForNodeUnsafe ::
+                         (MonadIO m, IsNode node, ToJSString markerType, HasCallStack) =>
+                           Internals -> Maybe node -> markerType -> Word -> m Range
+markerRangeForNodeUnsafe self node markerType index
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_markerRangeForNode (self) (maybeToNullable (fmap toNode node))
+             (toJSString markerType)
+             index))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Internals.markerRangeForNode Mozilla Internals.markerRangeForNode documentation> 
 markerRangeForNodeUnchecked ::
                             (MonadIO m, IsNode node, ToJSString markerType) =>
                               Internals -> Maybe node -> markerType -> Word -> m Range
@@ -1401,6 +1538,20 @@
             rangeLength))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Internals.rangeFromLocationAndLength Mozilla Internals.rangeFromLocationAndLength documentation> 
+rangeFromLocationAndLengthUnsafe ::
+                                 (MonadIO m, IsElement scope, HasCallStack) =>
+                                   Internals -> Maybe scope -> Int -> Int -> m Range
+rangeFromLocationAndLengthUnsafe self scope rangeLocation
+  rangeLength
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_rangeFromLocationAndLength (self)
+             (maybeToNullable (fmap toElement scope))
+             rangeLocation
+             rangeLength))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Internals.rangeFromLocationAndLength Mozilla Internals.rangeFromLocationAndLength documentation> 
 rangeFromLocationAndLengthUnchecked ::
                                     (MonadIO m, IsElement scope) =>
                                       Internals -> Maybe scope -> Int -> Int -> m Range
@@ -1501,6 +1652,17 @@
             rangeLength))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Internals.subrange Mozilla Internals.subrange documentation> 
+subrangeUnsafe ::
+               (MonadIO m, HasCallStack) =>
+                 Internals -> Maybe Range -> Int -> Int -> m Range
+subrangeUnsafe self range rangeLocation rangeLength
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_subrange (self) (maybeToNullable range) rangeLocation
+             rangeLength))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Internals.subrange Mozilla Internals.subrange documentation> 
 subrangeUnchecked ::
                   (MonadIO m) => Internals -> Maybe Range -> Int -> Int -> m Range
 subrangeUnchecked self range rangeLocation rangeLength
@@ -1529,6 +1691,16 @@
   = liftIO (void (js_rangeForDictionaryLookupAtLocation (self) x y))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Internals.rangeForDictionaryLookupAtLocation Mozilla Internals.rangeForDictionaryLookupAtLocation documentation> 
+rangeForDictionaryLookupAtLocationUnsafe ::
+                                         (MonadIO m, HasCallStack) =>
+                                           Internals -> Int -> Int -> m Range
+rangeForDictionaryLookupAtLocationUnsafe self x y
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_rangeForDictionaryLookupAtLocation (self) x y))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Internals.rangeForDictionaryLookupAtLocation Mozilla Internals.rangeForDictionaryLookupAtLocation documentation> 
 rangeForDictionaryLookupAtLocationUnchecked ::
                                             (MonadIO m) => Internals -> Int -> Int -> m Range
 rangeForDictionaryLookupAtLocationUnchecked self x y
@@ -1691,6 +1863,32 @@
             allowChildFrameContent))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Internals.nodesFromRect Mozilla Internals.nodesFromRect documentation> 
+nodesFromRectUnsafe ::
+                    (MonadIO m, IsDocument document, HasCallStack) =>
+                      Internals ->
+                        Maybe document ->
+                          Int ->
+                            Int ->
+                              Word -> Word -> Word -> Word -> Bool -> Bool -> Bool -> m NodeList
+nodesFromRectUnsafe self document x y topPadding rightPadding
+  bottomPadding leftPadding ignoreClipping allowShadowContent
+  allowChildFrameContent
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_nodesFromRect (self)
+             (maybeToNullable (fmap toDocument document))
+             x
+             y
+             topPadding
+             rightPadding
+             bottomPadding
+             leftPadding
+             ignoreClipping
+             allowShadowContent
+             allowChildFrameContent))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Internals.nodesFromRect Mozilla Internals.nodesFromRect documentation> 
 nodesFromRectUnchecked ::
                        (MonadIO m, IsDocument document) =>
                          Internals ->
@@ -1971,6 +2169,14 @@
   = liftIO (void (js_nonFastScrollableRects (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Internals.nonFastScrollableRects Mozilla Internals.nonFastScrollableRects documentation> 
+nonFastScrollableRectsUnsafe ::
+                             (MonadIO m, HasCallStack) => Internals -> m ClientRectList
+nonFastScrollableRectsUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_nonFastScrollableRects (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Internals.nonFastScrollableRects Mozilla Internals.nonFastScrollableRects documentation> 
 nonFastScrollableRectsUnchecked ::
                                 (MonadIO m) => Internals -> m ClientRectList
 nonFastScrollableRectsUnchecked self
@@ -2118,6 +2324,16 @@
       (void (js_openDummyInspectorFrontend (self) (toJSString url)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Internals.openDummyInspectorFrontend Mozilla Internals.openDummyInspectorFrontend documentation> 
+openDummyInspectorFrontendUnsafe ::
+                                 (MonadIO m, ToJSString url, HasCallStack) =>
+                                   Internals -> url -> m Window
+openDummyInspectorFrontendUnsafe self url
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_openDummyInspectorFrontend (self) (toJSString url)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Internals.openDummyInspectorFrontend Mozilla Internals.openDummyInspectorFrontend documentation> 
 openDummyInspectorFrontendUnchecked ::
                                     (MonadIO m, ToJSString url) => Internals -> url -> m Window
 openDummyInspectorFrontendUnchecked self url
@@ -2454,6 +2670,14 @@
 mallocStatistics_ self = liftIO (void (js_mallocStatistics (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Internals.mallocStatistics Mozilla Internals.mallocStatistics documentation> 
+mallocStatisticsUnsafe ::
+                       (MonadIO m, HasCallStack) => Internals -> m MallocStatistics
+mallocStatisticsUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_mallocStatistics (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Internals.mallocStatistics Mozilla Internals.mallocStatistics documentation> 
 mallocStatisticsUnchecked ::
                           (MonadIO m) => Internals -> m MallocStatistics
 mallocStatisticsUnchecked self
@@ -2474,6 +2698,14 @@
 typeConversions_ self = liftIO (void (js_typeConversions (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Internals.typeConversions Mozilla Internals.typeConversions documentation> 
+typeConversionsUnsafe ::
+                      (MonadIO m, HasCallStack) => Internals -> m TypeConversions
+typeConversionsUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_typeConversions (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Internals.typeConversions Mozilla Internals.typeConversions documentation> 
 typeConversionsUnchecked ::
                          (MonadIO m) => Internals -> m TypeConversions
 typeConversionsUnchecked self
@@ -2493,6 +2725,14 @@
 memoryInfo_ self = liftIO (void (js_memoryInfo (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Internals.memoryInfo Mozilla Internals.memoryInfo documentation> 
+memoryInfoUnsafe ::
+                 (MonadIO m, HasCallStack) => Internals -> m MemoryInfo
+memoryInfoUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_memoryInfo (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Internals.memoryInfo Mozilla Internals.memoryInfo documentation> 
 memoryInfoUnchecked :: (MonadIO m) => Internals -> m MemoryInfo
 memoryInfoUnchecked self
   = liftIO (fromJust . nullableToMaybe <$> (js_memoryInfo (self)))
@@ -2644,6 +2884,17 @@
             (maybeToNullable (fmap toArrayBuffer buffer))))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Internals.deserializeBuffer Mozilla Internals.deserializeBuffer documentation> 
+deserializeBufferUnsafe ::
+                        (MonadIO m, IsArrayBuffer buffer, HasCallStack) =>
+                          Internals -> Maybe buffer -> m SerializedScriptValue
+deserializeBufferUnsafe self buffer
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_deserializeBuffer (self)
+             (maybeToNullable (fmap toArrayBuffer buffer))))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Internals.deserializeBuffer Mozilla Internals.deserializeBuffer documentation> 
 deserializeBufferUnchecked ::
                            (MonadIO m, IsArrayBuffer buffer) =>
                              Internals -> Maybe buffer -> m SerializedScriptValue
@@ -2679,6 +2930,17 @@
             (maybeToNullable (fmap toSerializedScriptValue obj))))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Internals.serializeObject Mozilla Internals.serializeObject documentation> 
+serializeObjectUnsafe ::
+                      (MonadIO m, IsSerializedScriptValue obj, HasCallStack) =>
+                        Internals -> Maybe obj -> m ArrayBuffer
+serializeObjectUnsafe self obj
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_serializeObject (self)
+             (maybeToNullable (fmap toSerializedScriptValue obj))))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Internals.serializeObject Mozilla Internals.serializeObject documentation> 
 serializeObjectUnchecked ::
                          (MonadIO m, IsSerializedScriptValue obj) =>
                            Internals -> Maybe obj -> m ArrayBuffer
@@ -2863,6 +3125,19 @@
             (maybeToNullable (fmap toFloat32Array endTimes))))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Internals.createTimeRanges Mozilla Internals.createTimeRanges documentation> 
+createTimeRangesUnsafe ::
+                       (MonadIO m, IsFloat32Array startTimes, IsFloat32Array endTimes,
+                        HasCallStack) =>
+                         Internals -> Maybe startTimes -> Maybe endTimes -> m TimeRanges
+createTimeRangesUnsafe self startTimes endTimes
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_createTimeRanges (self)
+             (maybeToNullable (fmap toFloat32Array startTimes))
+             (maybeToNullable (fmap toFloat32Array endTimes))))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Internals.createTimeRanges Mozilla Internals.createTimeRanges documentation> 
 createTimeRangesUnchecked ::
                           (MonadIO m, IsFloat32Array startTimes, IsFloat32Array endTimes) =>
                             Internals -> Maybe startTimes -> Maybe endTimes -> m TimeRanges
@@ -2985,6 +3260,14 @@
 selectionBounds_ self = liftIO (void (js_selectionBounds (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Internals.selectionBounds Mozilla Internals.selectionBounds documentation> 
+selectionBoundsUnsafe ::
+                      (MonadIO m, HasCallStack) => Internals -> m ClientRect
+selectionBoundsUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_selectionBounds (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Internals.selectionBounds Mozilla Internals.selectionBounds documentation> 
 selectionBoundsUnchecked ::
                          (MonadIO m) => Internals -> m ClientRect
 selectionBoundsUnchecked self
@@ -3182,6 +3465,14 @@
             (MonadIO m) => Internals -> m (Maybe InternalSettings)
 getSettings self
   = liftIO (nullableToMaybe <$> (js_getSettings (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Internals.settings Mozilla Internals.settings documentation> 
+getSettingsUnsafe ::
+                  (MonadIO m, HasCallStack) => Internals -> m InternalSettings
+getSettingsUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getSettings (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Internals.settings Mozilla Internals.settings documentation> 
 getSettingsUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/KeyboardEvent.hs b/src/GHCJS/DOM/JSFFI/Generated/KeyboardEvent.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/KeyboardEvent.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/KeyboardEvent.hs
@@ -1,4 +1,9 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.KeyboardEvent
        (js_initKeyboardEvent, initKeyboardEvent,
         pattern DOM_KEY_LOCATION_STANDARD, pattern DOM_KEY_LOCATION_LEFT,
@@ -7,9 +12,10 @@
         js_getKeyLocation, getKeyLocation, js_getCtrlKey, getCtrlKey,
         js_getShiftKey, getShiftKey, js_getAltKey, getAltKey,
         js_getMetaKey, getMetaKey, js_getAltGraphKey, getAltGraphKey,
-        KeyboardEvent, castToKeyboardEvent, gTypeKeyboardEvent)
+        KeyboardEvent(..), gTypeKeyboardEvent)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -25,6 +31,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe
         "$1[\"initKeyboardEvent\"]($2, $3,\n$4, $5, $6, $7, $8, $9, $10,\n$11, $12)"
diff --git a/src/GHCJS/DOM/JSFFI/Generated/Location.hs b/src/GHCJS/DOM/JSFFI/Generated/Location.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/Location.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/Location.hs
@@ -1,4 +1,9 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.Location
        (js_assign, assign, js_replace, replace, js_reload, reload,
         js_toString, toString, toString_, js_setHref, setHref, js_getHref,
@@ -9,10 +14,11 @@
         getPathname, js_setSearch, setSearch, js_getSearch, getSearch,
         js_setHash, setHash, js_getHash, getHash, js_getOrigin, getOrigin,
         js_getAncestorOrigins, getAncestorOrigins,
-        getAncestorOriginsUnchecked, Location, castToLocation,
-        gTypeLocation)
+        getAncestorOriginsUnsafe, getAncestorOriginsUnchecked,
+        Location(..), gTypeLocation)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -28,6 +34,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"assign\"]($2)" js_assign ::
         Location -> JSString -> IO ()
@@ -203,6 +219,14 @@
                    (MonadIO m) => Location -> m (Maybe DOMStringList)
 getAncestorOrigins self
   = liftIO (nullableToMaybe <$> (js_getAncestorOrigins (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Location.ancestorOrigins Mozilla Location.ancestorOrigins documentation> 
+getAncestorOriginsUnsafe ::
+                         (MonadIO m, HasCallStack) => Location -> m DOMStringList
+getAncestorOriginsUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getAncestorOrigins (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Location.ancestorOrigins Mozilla Location.ancestorOrigins documentation> 
 getAncestorOriginsUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/MallocStatistics.hs b/src/GHCJS/DOM/JSFFI/Generated/MallocStatistics.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/MallocStatistics.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/MallocStatistics.hs
@@ -1,10 +1,16 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.MallocStatistics
        (js_getReservedVMBytes, getReservedVMBytes, js_getCommittedVMBytes,
         getCommittedVMBytes, js_getFreeListBytes, getFreeListBytes,
-        MallocStatistics, castToMallocStatistics, gTypeMallocStatistics)
+        MallocStatistics(..), gTypeMallocStatistics)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -20,6 +26,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"reservedVMBytes\"]"
         js_getReservedVMBytes :: MallocStatistics -> IO Word
diff --git a/src/GHCJS/DOM/JSFFI/Generated/MediaController.hs b/src/GHCJS/DOM/JSFFI/Generated/MediaController.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/MediaController.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/MediaController.hs
@@ -1,20 +1,26 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.MediaController
        (js_newMediaController, newMediaController, js_play, play,
         js_pause, pause, js_unpause, unpause, js_getBuffered, getBuffered,
-        getBufferedUnchecked, js_getSeekable, getSeekable,
-        getSeekableUnchecked, js_getDuration, getDuration,
-        js_setCurrentTime, setCurrentTime, js_getCurrentTime,
-        getCurrentTime, js_getPaused, getPaused, js_getPlayed, getPlayed,
-        getPlayedUnchecked, js_getPlaybackState, getPlaybackState,
-        js_setDefaultPlaybackRate, setDefaultPlaybackRate,
-        js_getDefaultPlaybackRate, getDefaultPlaybackRate,
-        js_setPlaybackRate, setPlaybackRate, js_getPlaybackRate,
-        getPlaybackRate, js_setVolume, setVolume, js_getVolume, getVolume,
-        js_setMuted, setMuted, js_getMuted, getMuted, MediaController,
-        castToMediaController, gTypeMediaController)
+        getBufferedUnsafe, getBufferedUnchecked, js_getSeekable,
+        getSeekable, getSeekableUnsafe, getSeekableUnchecked,
+        js_getDuration, getDuration, js_setCurrentTime, setCurrentTime,
+        js_getCurrentTime, getCurrentTime, js_getPaused, getPaused,
+        js_getPlayed, getPlayed, getPlayedUnsafe, getPlayedUnchecked,
+        js_getPlaybackState, getPlaybackState, js_setDefaultPlaybackRate,
+        setDefaultPlaybackRate, js_getDefaultPlaybackRate,
+        getDefaultPlaybackRate, js_setPlaybackRate, setPlaybackRate,
+        js_getPlaybackRate, getPlaybackRate, js_setVolume, setVolume,
+        js_getVolume, getVolume, js_setMuted, setMuted, js_getMuted,
+        getMuted, MediaController(..), gTypeMediaController)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -30,6 +36,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe
         "new window[\"MediaController\"]()" js_newMediaController ::
@@ -70,6 +86,14 @@
   = liftIO (nullableToMaybe <$> (js_getBuffered (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/MediaController.buffered Mozilla MediaController.buffered documentation> 
+getBufferedUnsafe ::
+                  (MonadIO m, HasCallStack) => MediaController -> m TimeRanges
+getBufferedUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getBuffered (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/MediaController.buffered Mozilla MediaController.buffered documentation> 
 getBufferedUnchecked ::
                      (MonadIO m) => MediaController -> m TimeRanges
 getBufferedUnchecked self
@@ -85,6 +109,14 @@
   = liftIO (nullableToMaybe <$> (js_getSeekable (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/MediaController.seekable Mozilla MediaController.seekable documentation> 
+getSeekableUnsafe ::
+                  (MonadIO m, HasCallStack) => MediaController -> m TimeRanges
+getSeekableUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getSeekable (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/MediaController.seekable Mozilla MediaController.seekable documentation> 
 getSeekableUnchecked ::
                      (MonadIO m) => MediaController -> m TimeRanges
 getSeekableUnchecked self
@@ -124,6 +156,14 @@
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/MediaController.played Mozilla MediaController.played documentation> 
 getPlayed :: (MonadIO m) => MediaController -> m (Maybe TimeRanges)
 getPlayed self = liftIO (nullableToMaybe <$> (js_getPlayed (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/MediaController.played Mozilla MediaController.played documentation> 
+getPlayedUnsafe ::
+                (MonadIO m, HasCallStack) => MediaController -> m TimeRanges
+getPlayedUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getPlayed (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/MediaController.played Mozilla MediaController.played documentation> 
 getPlayedUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/MediaControlsHost.hs b/src/GHCJS/DOM/JSFFI/Generated/MediaControlsHost.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/MediaControlsHost.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/MediaControlsHost.hs
@@ -1,4 +1,9 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.MediaControlsHost
        (js_sortedTrackListForMenu, sortedTrackListForMenu,
         sortedTrackListForMenu_, js_sortedTrackListForMenuAudio,
@@ -11,10 +16,12 @@
         js_exitedFullscreen, exitedFullscreen, js_enterFullscreenOptimized,
         enterFullscreenOptimized, js_mediaUIImageData, mediaUIImageData,
         mediaUIImageData_, js_getCaptionMenuOffItem, getCaptionMenuOffItem,
-        getCaptionMenuOffItemUnchecked, js_getCaptionMenuAutomaticItem,
-        getCaptionMenuAutomaticItem, getCaptionMenuAutomaticItemUnchecked,
-        js_getCaptionDisplayMode, getCaptionDisplayMode,
-        js_getTextTrackContainer, getTextTrackContainer,
+        getCaptionMenuOffItemUnsafe, getCaptionMenuOffItemUnchecked,
+        js_getCaptionMenuAutomaticItem, getCaptionMenuAutomaticItem,
+        getCaptionMenuAutomaticItemUnsafe,
+        getCaptionMenuAutomaticItemUnchecked, js_getCaptionDisplayMode,
+        getCaptionDisplayMode, js_getTextTrackContainer,
+        getTextTrackContainer, getTextTrackContainerUnsafe,
         getTextTrackContainerUnchecked, js_getMediaPlaybackAllowsInline,
         getMediaPlaybackAllowsInline, js_getSupportsFullscreen,
         getSupportsFullscreen, js_getUserGestureRequired,
@@ -23,10 +30,11 @@
         getExternalDeviceType, js_setControlsDependOnPageScaleFactor,
         setControlsDependOnPageScaleFactor,
         js_getControlsDependOnPageScaleFactor,
-        getControlsDependOnPageScaleFactor, MediaControlsHost,
-        castToMediaControlsHost, gTypeMediaControlsHost)
+        getControlsDependOnPageScaleFactor, MediaControlsHost(..),
+        gTypeMediaControlsHost)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -42,6 +50,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe
         "$1[\"sortedTrackListForMenu\"]($2)" js_sortedTrackListForMenu ::
@@ -199,6 +217,14 @@
   = liftIO (nullableToMaybe <$> (js_getCaptionMenuOffItem (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/MediaControlsHost.captionMenuOffItem Mozilla MediaControlsHost.captionMenuOffItem documentation> 
+getCaptionMenuOffItemUnsafe ::
+                            (MonadIO m, HasCallStack) => MediaControlsHost -> m TextTrack
+getCaptionMenuOffItemUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getCaptionMenuOffItem (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/MediaControlsHost.captionMenuOffItem Mozilla MediaControlsHost.captionMenuOffItem documentation> 
 getCaptionMenuOffItemUnchecked ::
                                (MonadIO m) => MediaControlsHost -> m TextTrack
 getCaptionMenuOffItemUnchecked self
@@ -217,6 +243,14 @@
       (nullableToMaybe <$> (js_getCaptionMenuAutomaticItem (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/MediaControlsHost.captionMenuAutomaticItem Mozilla MediaControlsHost.captionMenuAutomaticItem documentation> 
+getCaptionMenuAutomaticItemUnsafe ::
+                                  (MonadIO m, HasCallStack) => MediaControlsHost -> m TextTrack
+getCaptionMenuAutomaticItemUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getCaptionMenuAutomaticItem (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/MediaControlsHost.captionMenuAutomaticItem Mozilla MediaControlsHost.captionMenuAutomaticItem documentation> 
 getCaptionMenuAutomaticItemUnchecked ::
                                      (MonadIO m) => MediaControlsHost -> m TextTrack
 getCaptionMenuAutomaticItemUnchecked self
@@ -242,6 +276,14 @@
                       (MonadIO m) => MediaControlsHost -> m (Maybe HTMLElement)
 getTextTrackContainer self
   = liftIO (nullableToMaybe <$> (js_getTextTrackContainer (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/MediaControlsHost.textTrackContainer Mozilla MediaControlsHost.textTrackContainer documentation> 
+getTextTrackContainerUnsafe ::
+                            (MonadIO m, HasCallStack) => MediaControlsHost -> m HTMLElement
+getTextTrackContainerUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getTextTrackContainer (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/MediaControlsHost.textTrackContainer Mozilla MediaControlsHost.textTrackContainer documentation> 
 getTextTrackContainerUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/MediaElementAudioSourceNode.hs b/src/GHCJS/DOM/JSFFI/Generated/MediaElementAudioSourceNode.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/MediaElementAudioSourceNode.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/MediaElementAudioSourceNode.hs
@@ -1,10 +1,16 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.MediaElementAudioSourceNode
-       (js_getMediaElement, getMediaElement, getMediaElementUnchecked,
-        MediaElementAudioSourceNode, castToMediaElementAudioSourceNode,
+       (js_getMediaElement, getMediaElement, getMediaElementUnsafe,
+        getMediaElementUnchecked, MediaElementAudioSourceNode(..),
         gTypeMediaElementAudioSourceNode)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -20,6 +26,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"mediaElement\"]"
         js_getMediaElement ::
@@ -31,6 +47,15 @@
                   MediaElementAudioSourceNode -> m (Maybe HTMLMediaElement)
 getMediaElement self
   = liftIO (nullableToMaybe <$> (js_getMediaElement (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/MediaElementAudioSourceNode.mediaElement Mozilla MediaElementAudioSourceNode.mediaElement documentation> 
+getMediaElementUnsafe ::
+                      (MonadIO m, HasCallStack) =>
+                        MediaElementAudioSourceNode -> m HTMLMediaElement
+getMediaElementUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getMediaElement (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/MediaElementAudioSourceNode.mediaElement Mozilla MediaElementAudioSourceNode.mediaElement documentation> 
 getMediaElementUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/MediaError.hs b/src/GHCJS/DOM/JSFFI/Generated/MediaError.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/MediaError.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/MediaError.hs
@@ -1,11 +1,17 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.MediaError
        (pattern MEDIA_ERR_ABORTED, pattern MEDIA_ERR_NETWORK,
         pattern MEDIA_ERR_DECODE, pattern MEDIA_ERR_SRC_NOT_SUPPORTED,
-        pattern MEDIA_ERR_ENCRYPTED, js_getCode, getCode, MediaError,
-        castToMediaError, gTypeMediaError)
+        pattern MEDIA_ERR_ENCRYPTED, js_getCode, getCode, MediaError(..),
+        gTypeMediaError)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -21,6 +27,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
 pattern MEDIA_ERR_ABORTED = 1
 pattern MEDIA_ERR_NETWORK = 2
 pattern MEDIA_ERR_DECODE = 3
diff --git a/src/GHCJS/DOM/JSFFI/Generated/MediaKeyError.hs b/src/GHCJS/DOM/JSFFI/Generated/MediaKeyError.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/MediaKeyError.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/MediaKeyError.hs
@@ -1,12 +1,18 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.MediaKeyError
        (pattern MEDIA_KEYERR_UNKNOWN, pattern MEDIA_KEYERR_CLIENT,
         pattern MEDIA_KEYERR_SERVICE, pattern MEDIA_KEYERR_OUTPUT,
         pattern MEDIA_KEYERR_HARDWARECHANGE, pattern MEDIA_KEYERR_DOMAIN,
         js_getCode, getCode, js_getSystemCode, getSystemCode,
-        MediaKeyError, castToMediaKeyError, gTypeMediaKeyError)
+        MediaKeyError(..), gTypeMediaKeyError)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -22,6 +28,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
 pattern MEDIA_KEYERR_UNKNOWN = 1
 pattern MEDIA_KEYERR_CLIENT = 2
 pattern MEDIA_KEYERR_SERVICE = 3
diff --git a/src/GHCJS/DOM/JSFFI/Generated/MediaKeyEvent.hs b/src/GHCJS/DOM/JSFFI/Generated/MediaKeyEvent.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/MediaKeyEvent.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/MediaKeyEvent.hs
@@ -1,13 +1,20 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.MediaKeyEvent
        (js_getKeySystem, getKeySystem, js_getSessionId, getSessionId,
-        js_getInitData, getInitData, getInitDataUnchecked, js_getMessage,
-        getMessage, getMessageUnchecked, js_getDefaultURL, getDefaultURL,
-        js_getErrorCode, getErrorCode, getErrorCodeUnchecked,
-        js_getSystemCode, getSystemCode, MediaKeyEvent,
-        castToMediaKeyEvent, gTypeMediaKeyEvent)
+        js_getInitData, getInitData, getInitDataUnsafe,
+        getInitDataUnchecked, js_getMessage, getMessage, getMessageUnsafe,
+        getMessageUnchecked, js_getDefaultURL, getDefaultURL,
+        js_getErrorCode, getErrorCode, getErrorCodeUnsafe,
+        getErrorCodeUnchecked, js_getSystemCode, getSystemCode,
+        MediaKeyEvent(..), gTypeMediaKeyEvent)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -23,6 +30,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"keySystem\"]"
         js_getKeySystem :: MediaKeyEvent -> IO JSString
@@ -51,6 +68,14 @@
   = liftIO (nullableToMaybe <$> (js_getInitData (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/MediaKeyEvent.initData Mozilla MediaKeyEvent.initData documentation> 
+getInitDataUnsafe ::
+                  (MonadIO m, HasCallStack) => MediaKeyEvent -> m Uint8Array
+getInitDataUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getInitData (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/MediaKeyEvent.initData Mozilla MediaKeyEvent.initData documentation> 
 getInitDataUnchecked ::
                      (MonadIO m) => MediaKeyEvent -> m Uint8Array
 getInitDataUnchecked self
@@ -65,6 +90,14 @@
   = liftIO (nullableToMaybe <$> (js_getMessage (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/MediaKeyEvent.message Mozilla MediaKeyEvent.message documentation> 
+getMessageUnsafe ::
+                 (MonadIO m, HasCallStack) => MediaKeyEvent -> m Uint8Array
+getMessageUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getMessage (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/MediaKeyEvent.message Mozilla MediaKeyEvent.message documentation> 
 getMessageUnchecked :: (MonadIO m) => MediaKeyEvent -> m Uint8Array
 getMessageUnchecked self
   = liftIO (fromJust . nullableToMaybe <$> (js_getMessage (self)))
@@ -86,6 +119,14 @@
              (MonadIO m) => MediaKeyEvent -> m (Maybe MediaKeyError)
 getErrorCode self
   = liftIO (nullableToMaybe <$> (js_getErrorCode (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/MediaKeyEvent.errorCode Mozilla MediaKeyEvent.errorCode documentation> 
+getErrorCodeUnsafe ::
+                   (MonadIO m, HasCallStack) => MediaKeyEvent -> m MediaKeyError
+getErrorCodeUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getErrorCode (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/MediaKeyEvent.errorCode Mozilla MediaKeyEvent.errorCode documentation> 
 getErrorCodeUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/MediaKeyMessageEvent.hs b/src/GHCJS/DOM/JSFFI/Generated/MediaKeyMessageEvent.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/MediaKeyMessageEvent.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/MediaKeyMessageEvent.hs
@@ -1,10 +1,16 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.MediaKeyMessageEvent
-       (js_getMessage, getMessage, getMessageUnchecked,
-        js_getDestinationURL, getDestinationURL, MediaKeyMessageEvent,
-        castToMediaKeyMessageEvent, gTypeMediaKeyMessageEvent)
+       (js_getMessage, getMessage, getMessageUnsafe, getMessageUnchecked,
+        js_getDestinationURL, getDestinationURL, MediaKeyMessageEvent(..),
+        gTypeMediaKeyMessageEvent)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -20,6 +26,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"message\"]" js_getMessage ::
         MediaKeyMessageEvent -> IO (Nullable Uint8Array)
@@ -29,6 +45,14 @@
            (MonadIO m) => MediaKeyMessageEvent -> m (Maybe Uint8Array)
 getMessage self
   = liftIO (nullableToMaybe <$> (js_getMessage (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/WebKitMediaKeyMessageEvent.message Mozilla WebKitMediaKeyMessageEvent.message documentation> 
+getMessageUnsafe ::
+                 (MonadIO m, HasCallStack) => MediaKeyMessageEvent -> m Uint8Array
+getMessageUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getMessage (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/WebKitMediaKeyMessageEvent.message Mozilla WebKitMediaKeyMessageEvent.message documentation> 
 getMessageUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/MediaKeyNeededEvent.hs b/src/GHCJS/DOM/JSFFI/Generated/MediaKeyNeededEvent.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/MediaKeyNeededEvent.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/MediaKeyNeededEvent.hs
@@ -1,10 +1,16 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.MediaKeyNeededEvent
-       (js_getInitData, getInitData, getInitDataUnchecked,
-        MediaKeyNeededEvent, castToMediaKeyNeededEvent,
+       (js_getInitData, getInitData, getInitDataUnsafe,
+        getInitDataUnchecked, MediaKeyNeededEvent(..),
         gTypeMediaKeyNeededEvent)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -20,6 +26,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"initData\"]" js_getInitData
         :: MediaKeyNeededEvent -> IO (Nullable Uint8Array)
@@ -29,6 +45,14 @@
             (MonadIO m) => MediaKeyNeededEvent -> m (Maybe Uint8Array)
 getInitData self
   = liftIO (nullableToMaybe <$> (js_getInitData (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/MediaKeyNeededEvent.initData Mozilla MediaKeyNeededEvent.initData documentation> 
+getInitDataUnsafe ::
+                  (MonadIO m, HasCallStack) => MediaKeyNeededEvent -> m Uint8Array
+getInitDataUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getInitData (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/MediaKeyNeededEvent.initData Mozilla MediaKeyNeededEvent.initData documentation> 
 getInitDataUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/MediaKeySession.hs b/src/GHCJS/DOM/JSFFI/Generated/MediaKeySession.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/MediaKeySession.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/MediaKeySession.hs
@@ -1,11 +1,17 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.MediaKeySession
        (js_update, update, js_close, close, js_getError, getError,
-        getErrorUnchecked, js_getKeySystem, getKeySystem, js_getSessionId,
-        getSessionId, webKitKeyAdded, webKitKeyError, webKitKeyMessage,
-        MediaKeySession, castToMediaKeySession, gTypeMediaKeySession)
+        getErrorUnsafe, getErrorUnchecked, js_getKeySystem, getKeySystem,
+        js_getSessionId, getSessionId, webKitKeyAdded, webKitKeyError,
+        webKitKeyMessage, MediaKeySession(..), gTypeMediaKeySession)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -21,6 +27,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"update\"]($2)" js_update ::
         MediaKeySession -> Nullable Uint8Array -> IO ()
@@ -47,6 +63,14 @@
 getError ::
          (MonadIO m) => MediaKeySession -> m (Maybe MediaKeyError)
 getError self = liftIO (nullableToMaybe <$> (js_getError (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/WebKitMediaKeySession.error Mozilla WebKitMediaKeySession.error documentation> 
+getErrorUnsafe ::
+               (MonadIO m, HasCallStack) => MediaKeySession -> m MediaKeyError
+getErrorUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getError (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/WebKitMediaKeySession.error Mozilla WebKitMediaKeySession.error documentation> 
 getErrorUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/MediaKeys.hs b/src/GHCJS/DOM/JSFFI/Generated/MediaKeys.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/MediaKeys.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/MediaKeys.hs
@@ -1,11 +1,17 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.MediaKeys
        (js_newMediaKeys, newMediaKeys, js_createSession, createSession,
-        createSession_, createSessionUnchecked, js_isTypeSupported,
-        isTypeSupported, isTypeSupported_, js_getKeySystem, getKeySystem,
-        MediaKeys, castToMediaKeys, gTypeMediaKeys)
+        createSession_, createSessionUnsafe, createSessionUnchecked,
+        js_isTypeSupported, isTypeSupported, isTypeSupported_,
+        js_getKeySystem, getKeySystem, MediaKeys(..), gTypeMediaKeys)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -21,6 +27,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe
         "new window[\"WebKitMediaKeys\"]($1)" js_newMediaKeys ::
@@ -56,6 +72,18 @@
       (void
          (js_createSession (self) (toJSString type')
             (maybeToNullable (fmap toUint8Array initData))))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/WebKitMediaKeys.createSession Mozilla WebKitMediaKeys.createSession documentation> 
+createSessionUnsafe ::
+                    (MonadIO m, ToJSString type', IsUint8Array initData,
+                     HasCallStack) =>
+                      MediaKeys -> type' -> Maybe initData -> m MediaKeySession
+createSessionUnsafe self type' initData
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_createSession (self) (toJSString type')
+             (maybeToNullable (fmap toUint8Array initData))))
+         >>= maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/WebKitMediaKeys.createSession Mozilla WebKitMediaKeys.createSession documentation> 
 createSessionUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/MediaList.hs b/src/GHCJS/DOM/JSFFI/Generated/MediaList.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/MediaList.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/MediaList.hs
@@ -1,12 +1,18 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.MediaList
-       (js_item, item, item_, itemUnchecked, js_deleteMedium,
+       (js_item, item, item_, itemUnsafe, itemUnchecked, js_deleteMedium,
         deleteMedium, js_appendMedium, appendMedium, js_setMediaText,
-        setMediaText, js_getMediaText, getMediaText, getMediaTextUnchecked,
-        js_getLength, getLength, MediaList, castToMediaList,
+        setMediaText, js_getMediaText, getMediaText, getMediaTextUnsafe,
+        getMediaTextUnchecked, js_getLength, getLength, MediaList(..),
         gTypeMediaList)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -22,6 +28,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"item\"]($2)" js_item ::
         MediaList -> Word -> IO (Nullable JSString)
@@ -38,6 +54,15 @@
 item_ self index = liftIO (void (js_item (self) index))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/MediaList.item Mozilla MediaList.item documentation> 
+itemUnsafe ::
+           (MonadIO m, HasCallStack, FromJSString result) =>
+             MediaList -> Word -> m result
+itemUnsafe self index
+  = liftIO
+      ((fromMaybeJSString <$> (js_item (self) index)) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/MediaList.item Mozilla MediaList.item documentation> 
 itemUnchecked ::
               (MonadIO m, FromJSString result) => MediaList -> Word -> m result
 itemUnchecked self index
@@ -78,6 +103,15 @@
              (MonadIO m, FromJSString result) => MediaList -> m (Maybe result)
 getMediaText self
   = liftIO (fromMaybeJSString <$> (js_getMediaText (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/MediaList.mediaText Mozilla MediaList.mediaText documentation> 
+getMediaTextUnsafe ::
+                   (MonadIO m, HasCallStack, FromJSString result) =>
+                     MediaList -> m result
+getMediaTextUnsafe self
+  = liftIO
+      ((fromMaybeJSString <$> (js_getMediaText (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/MediaList.mediaText Mozilla MediaList.mediaText documentation> 
 getMediaTextUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/MediaQueryList.hs b/src/GHCJS/DOM/JSFFI/Generated/MediaQueryList.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/MediaQueryList.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/MediaQueryList.hs
@@ -1,10 +1,16 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.MediaQueryList
        (js_addListener, addListener, js_removeListener, removeListener,
-        js_getMedia, getMedia, js_getMatches, getMatches, MediaQueryList,
-        castToMediaQueryList, gTypeMediaQueryList)
+        js_getMedia, getMedia, js_getMatches, getMatches,
+        MediaQueryList(..), gTypeMediaQueryList)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -20,6 +26,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"addListener\"]($2)"
         js_addListener ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/MediaQueryListListener.hs b/src/GHCJS/DOM/JSFFI/Generated/MediaQueryListListener.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/MediaQueryListListener.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/MediaQueryListListener.hs
@@ -1,9 +1,15 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.MediaQueryListListener
        (newMediaQueryListListener, newMediaQueryListListenerSync,
         newMediaQueryListListenerAsync, MediaQueryListListener)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -19,6 +25,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/MediaQueryListListener Mozilla MediaQueryListListener documentation> 
 newMediaQueryListListener ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/MediaSource.hs b/src/GHCJS/DOM/JSFFI/Generated/MediaSource.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/MediaSource.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/MediaSource.hs
@@ -1,16 +1,24 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.MediaSource
        (js_newMediaSource, newMediaSource, js_addSourceBuffer,
-        addSourceBuffer, addSourceBuffer_, addSourceBufferUnchecked,
-        js_removeSourceBuffer, removeSourceBuffer, js_endOfStream,
-        endOfStream, js_isTypeSupported, isTypeSupported, isTypeSupported_,
-        js_getSourceBuffers, getSourceBuffers, getSourceBuffersUnchecked,
-        js_getActiveSourceBuffers, getActiveSourceBuffers,
+        addSourceBuffer, addSourceBuffer_, addSourceBufferUnsafe,
+        addSourceBufferUnchecked, js_removeSourceBuffer,
+        removeSourceBuffer, js_endOfStream, endOfStream,
+        js_isTypeSupported, isTypeSupported, isTypeSupported_,
+        js_getSourceBuffers, getSourceBuffers, getSourceBuffersUnsafe,
+        getSourceBuffersUnchecked, js_getActiveSourceBuffers,
+        getActiveSourceBuffers, getActiveSourceBuffersUnsafe,
         getActiveSourceBuffersUnchecked, js_setDuration, setDuration,
         js_getDuration, getDuration, js_getReadyState, getReadyState,
-        MediaSource, castToMediaSource, gTypeMediaSource)
+        MediaSource(..), gTypeMediaSource)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -26,6 +34,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "new window[\"MediaSource\"]()"
         js_newMediaSource :: IO MediaSource
@@ -54,6 +72,16 @@
   = liftIO (void (js_addSourceBuffer (self) (toJSString type')))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/MediaSource.addSourceBuffer Mozilla MediaSource.addSourceBuffer documentation> 
+addSourceBufferUnsafe ::
+                      (MonadIO m, ToJSString type', HasCallStack) =>
+                        MediaSource -> type' -> m SourceBuffer
+addSourceBufferUnsafe self type'
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_addSourceBuffer (self) (toJSString type')))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/MediaSource.addSourceBuffer Mozilla MediaSource.addSourceBuffer documentation> 
 addSourceBufferUnchecked ::
                          (MonadIO m, ToJSString type') =>
                            MediaSource -> type' -> m SourceBuffer
@@ -108,6 +136,14 @@
   = liftIO (nullableToMaybe <$> (js_getSourceBuffers (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/MediaSource.sourceBuffers Mozilla MediaSource.sourceBuffers documentation> 
+getSourceBuffersUnsafe ::
+                       (MonadIO m, HasCallStack) => MediaSource -> m SourceBufferList
+getSourceBuffersUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getSourceBuffers (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/MediaSource.sourceBuffers Mozilla MediaSource.sourceBuffers documentation> 
 getSourceBuffersUnchecked ::
                           (MonadIO m) => MediaSource -> m SourceBufferList
 getSourceBuffersUnchecked self
@@ -123,6 +159,14 @@
                        (MonadIO m) => MediaSource -> m (Maybe SourceBufferList)
 getActiveSourceBuffers self
   = liftIO (nullableToMaybe <$> (js_getActiveSourceBuffers (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/MediaSource.activeSourceBuffers Mozilla MediaSource.activeSourceBuffers documentation> 
+getActiveSourceBuffersUnsafe ::
+                             (MonadIO m, HasCallStack) => MediaSource -> m SourceBufferList
+getActiveSourceBuffersUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getActiveSourceBuffers (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/MediaSource.activeSourceBuffers Mozilla MediaSource.activeSourceBuffers documentation> 
 getActiveSourceBuffersUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/MediaSourceStates.hs b/src/GHCJS/DOM/JSFFI/Generated/MediaSourceStates.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/MediaSourceStates.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/MediaSourceStates.hs
@@ -1,14 +1,21 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.MediaSourceStates
        (js_getSourceType, getSourceType, js_getSourceId, getSourceId,
-        js_getWidth, getWidth, getWidthUnchecked, js_getHeight, getHeight,
-        getHeightUnchecked, js_getFrameRate, getFrameRate,
+        js_getWidth, getWidth, getWidthUnsafe, getWidthUnchecked,
+        js_getHeight, getHeight, getHeightUnsafe, getHeightUnchecked,
+        js_getFrameRate, getFrameRate, getFrameRateUnsafe,
         getFrameRateUnchecked, js_getAspectRatio, getAspectRatio,
-        getAspectRatioUnchecked, js_getFacingMode, getFacingMode,
-        js_getVolume, getVolume, getVolumeUnchecked, MediaSourceStates,
-        castToMediaSourceStates, gTypeMediaSourceStates)
+        getAspectRatioUnsafe, getAspectRatioUnchecked, js_getFacingMode,
+        getFacingMode, js_getVolume, getVolume, getVolumeUnsafe,
+        getVolumeUnchecked, MediaSourceStates(..), gTypeMediaSourceStates)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -24,6 +31,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"sourceType\"]"
         js_getSourceType :: MediaSourceStates -> IO JSVal
@@ -52,6 +69,14 @@
   = liftIO ((js_getWidth (self)) >>= fromJSValUnchecked)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/MediaSourceStates.width Mozilla MediaSourceStates.width documentation> 
+getWidthUnsafe ::
+               (MonadIO m, HasCallStack) => MediaSourceStates -> m Word
+getWidthUnsafe self
+  = liftIO
+      (((js_getWidth (self)) >>= fromJSValUnchecked) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/MediaSourceStates.width Mozilla MediaSourceStates.width documentation> 
 getWidthUnchecked :: (MonadIO m) => MediaSourceStates -> m Word
 getWidthUnchecked self
   = liftIO ((js_getWidth (self)) >>= fromJSValUnchecked)
@@ -65,6 +90,14 @@
   = liftIO ((js_getHeight (self)) >>= fromJSValUnchecked)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/MediaSourceStates.height Mozilla MediaSourceStates.height documentation> 
+getHeightUnsafe ::
+                (MonadIO m, HasCallStack) => MediaSourceStates -> m Word
+getHeightUnsafe self
+  = liftIO
+      (((js_getHeight (self)) >>= fromJSValUnchecked) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/MediaSourceStates.height Mozilla MediaSourceStates.height documentation> 
 getHeightUnchecked :: (MonadIO m) => MediaSourceStates -> m Word
 getHeightUnchecked self
   = liftIO ((js_getHeight (self)) >>= fromJSValUnchecked)
@@ -78,6 +111,14 @@
   = liftIO ((js_getFrameRate (self)) >>= fromJSValUnchecked)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/MediaSourceStates.frameRate Mozilla MediaSourceStates.frameRate documentation> 
+getFrameRateUnsafe ::
+                   (MonadIO m, HasCallStack) => MediaSourceStates -> m Float
+getFrameRateUnsafe self
+  = liftIO
+      (((js_getFrameRate (self)) >>= fromJSValUnchecked) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/MediaSourceStates.frameRate Mozilla MediaSourceStates.frameRate documentation> 
 getFrameRateUnchecked ::
                       (MonadIO m) => MediaSourceStates -> m Float
 getFrameRateUnchecked self
@@ -93,6 +134,14 @@
   = liftIO ((js_getAspectRatio (self)) >>= fromJSValUnchecked)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/MediaSourceStates.aspectRatio Mozilla MediaSourceStates.aspectRatio documentation> 
+getAspectRatioUnsafe ::
+                     (MonadIO m, HasCallStack) => MediaSourceStates -> m Float
+getAspectRatioUnsafe self
+  = liftIO
+      (((js_getAspectRatio (self)) >>= fromJSValUnchecked) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/MediaSourceStates.aspectRatio Mozilla MediaSourceStates.aspectRatio documentation> 
 getAspectRatioUnchecked ::
                         (MonadIO m) => MediaSourceStates -> m Float
 getAspectRatioUnchecked self
@@ -114,6 +163,14 @@
 getVolume :: (MonadIO m) => MediaSourceStates -> m (Maybe Word)
 getVolume self
   = liftIO ((js_getVolume (self)) >>= fromJSValUnchecked)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/MediaSourceStates.volume Mozilla MediaSourceStates.volume documentation> 
+getVolumeUnsafe ::
+                (MonadIO m, HasCallStack) => MediaSourceStates -> m Word
+getVolumeUnsafe self
+  = liftIO
+      (((js_getVolume (self)) >>= fromJSValUnchecked) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/MediaSourceStates.volume Mozilla MediaSourceStates.volume documentation> 
 getVolumeUnchecked :: (MonadIO m) => MediaSourceStates -> m Word
diff --git a/src/GHCJS/DOM/JSFFI/Generated/MediaStream.hs b/src/GHCJS/DOM/JSFFI/Generated/MediaStream.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/MediaStream.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/MediaStream.hs
@@ -1,4 +1,9 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.MediaStream
        (js_newMediaStream, newMediaStream, js_newMediaStream',
         newMediaStream', js_newMediaStream'', newMediaStream'',
@@ -6,12 +11,13 @@
         js_getVideoTracks, getVideoTracks, getVideoTracks_, js_getTracks,
         getTracks, getTracks_, js_addTrack, addTrack, js_removeTrack,
         removeTrack, js_getTrackById, getTrackById, getTrackById_,
-        getTrackByIdUnchecked, js_clone, clone, clone_, cloneUnchecked,
-        js_getId, getId, js_getActive, getActive, active, inactive,
-        addTrackEvent, removeTrackEvent, MediaStream, castToMediaStream,
-        gTypeMediaStream)
+        getTrackByIdUnsafe, getTrackByIdUnchecked, js_clone, clone, clone_,
+        cloneUnsafe, cloneUnchecked, js_getId, getId, js_getActive,
+        getActive, active, inactive, addTrackEvent, removeTrackEvent,
+        MediaStream(..), gTypeMediaStream)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -27,6 +33,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe
         "new window[\"webkitMediaStream\"]()" js_newMediaStream ::
@@ -140,6 +156,16 @@
   = liftIO (void (js_getTrackById (self) (toJSString trackId)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/webkitMediaStream.getTrackById Mozilla webkitMediaStream.getTrackById documentation> 
+getTrackByIdUnsafe ::
+                   (MonadIO m, ToJSString trackId, HasCallStack) =>
+                     MediaStream -> trackId -> m MediaStreamTrack
+getTrackByIdUnsafe self trackId
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_getTrackById (self) (toJSString trackId)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/webkitMediaStream.getTrackById Mozilla webkitMediaStream.getTrackById documentation> 
 getTrackByIdUnchecked ::
                       (MonadIO m, ToJSString trackId) =>
                         MediaStream -> trackId -> m MediaStreamTrack
@@ -158,6 +184,14 @@
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/webkitMediaStream.clone Mozilla webkitMediaStream.clone documentation> 
 clone_ :: (MonadIO m) => MediaStream -> m ()
 clone_ self = liftIO (void (js_clone (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/webkitMediaStream.clone Mozilla webkitMediaStream.clone documentation> 
+cloneUnsafe ::
+            (MonadIO m, HasCallStack) => MediaStream -> m MediaStream
+cloneUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_clone (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/webkitMediaStream.clone Mozilla webkitMediaStream.clone documentation> 
 cloneUnchecked :: (MonadIO m) => MediaStream -> m MediaStream
diff --git a/src/GHCJS/DOM/JSFFI/Generated/MediaStreamAudioDestinationNode.hs b/src/GHCJS/DOM/JSFFI/Generated/MediaStreamAudioDestinationNode.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/MediaStreamAudioDestinationNode.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/MediaStreamAudioDestinationNode.hs
@@ -1,11 +1,16 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.MediaStreamAudioDestinationNode
-       (js_getStream, getStream, getStreamUnchecked,
-        MediaStreamAudioDestinationNode,
-        castToMediaStreamAudioDestinationNode,
+       (js_getStream, getStream, getStreamUnsafe, getStreamUnchecked,
+        MediaStreamAudioDestinationNode(..),
         gTypeMediaStreamAudioDestinationNode)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -21,6 +26,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"stream\"]" js_getStream ::
         MediaStreamAudioDestinationNode -> IO (Nullable MediaStream)
@@ -30,6 +45,15 @@
           (MonadIO m) =>
             MediaStreamAudioDestinationNode -> m (Maybe MediaStream)
 getStream self = liftIO (nullableToMaybe <$> (js_getStream (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/MediaStreamAudioDestinationNode.stream Mozilla MediaStreamAudioDestinationNode.stream documentation> 
+getStreamUnsafe ::
+                (MonadIO m, HasCallStack) =>
+                  MediaStreamAudioDestinationNode -> m MediaStream
+getStreamUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getStream (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/MediaStreamAudioDestinationNode.stream Mozilla MediaStreamAudioDestinationNode.stream documentation> 
 getStreamUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/MediaStreamAudioSourceNode.hs b/src/GHCJS/DOM/JSFFI/Generated/MediaStreamAudioSourceNode.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/MediaStreamAudioSourceNode.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/MediaStreamAudioSourceNode.hs
@@ -1,10 +1,16 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.MediaStreamAudioSourceNode
-       (js_getMediaStream, getMediaStream, getMediaStreamUnchecked,
-        MediaStreamAudioSourceNode, castToMediaStreamAudioSourceNode,
+       (js_getMediaStream, getMediaStream, getMediaStreamUnsafe,
+        getMediaStreamUnchecked, MediaStreamAudioSourceNode(..),
         gTypeMediaStreamAudioSourceNode)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -20,6 +26,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"mediaStream\"]"
         js_getMediaStream ::
@@ -30,6 +46,15 @@
                (MonadIO m) => MediaStreamAudioSourceNode -> m (Maybe MediaStream)
 getMediaStream self
   = liftIO (nullableToMaybe <$> (js_getMediaStream (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/MediaStreamAudioSourceNode.mediaStream Mozilla MediaStreamAudioSourceNode.mediaStream documentation> 
+getMediaStreamUnsafe ::
+                     (MonadIO m, HasCallStack) =>
+                       MediaStreamAudioSourceNode -> m MediaStream
+getMediaStreamUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getMediaStream (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/MediaStreamAudioSourceNode.mediaStream Mozilla MediaStreamAudioSourceNode.mediaStream documentation> 
 getMediaStreamUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/MediaStreamEvent.hs b/src/GHCJS/DOM/JSFFI/Generated/MediaStreamEvent.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/MediaStreamEvent.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/MediaStreamEvent.hs
@@ -1,9 +1,15 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.MediaStreamEvent
-       (js_getStream, getStream, getStreamUnchecked, MediaStreamEvent,
-        castToMediaStreamEvent, gTypeMediaStreamEvent)
+       (js_getStream, getStream, getStreamUnsafe, getStreamUnchecked,
+        MediaStreamEvent(..), gTypeMediaStreamEvent)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -19,6 +25,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"stream\"]" js_getStream ::
         MediaStreamEvent -> IO (Nullable MediaStream)
@@ -27,6 +43,14 @@
 getStream ::
           (MonadIO m) => MediaStreamEvent -> m (Maybe MediaStream)
 getStream self = liftIO (nullableToMaybe <$> (js_getStream (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/MediaStreamEvent.stream Mozilla MediaStreamEvent.stream documentation> 
+getStreamUnsafe ::
+                (MonadIO m, HasCallStack) => MediaStreamEvent -> m MediaStream
+getStreamUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getStream (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/MediaStreamEvent.stream Mozilla MediaStreamEvent.stream documentation> 
 getStreamUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/MediaStreamTrack.hs b/src/GHCJS/DOM/JSFFI/Generated/MediaStreamTrack.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/MediaStreamTrack.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/MediaStreamTrack.hs
@@ -1,18 +1,26 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.MediaStreamTrack
        (js_getSources, getSources, js_getConstraints, getConstraints,
-        getConstraints_, getConstraintsUnchecked, js_states, states,
-        states_, statesUnchecked, js_getCapabilities, getCapabilities,
-        getCapabilities_, getCapabilitiesUnchecked, js_applyConstraints,
-        applyConstraints, js_clone, clone, clone_, cloneUnchecked, js_stop,
-        stop, js_getKind, getKind, js_getId, getId, js_getLabel, getLabel,
-        js_setEnabled, setEnabled, js_getEnabled, getEnabled, js_getMuted,
-        getMuted, mute, unmute, js_get_readonly, get_readonly,
-        js_getRemote, getRemote, js_getReadyState, getReadyState, started,
-        ended, overConstrained, MediaStreamTrack, castToMediaStreamTrack,
-        gTypeMediaStreamTrack, IsMediaStreamTrack, toMediaStreamTrack)
+        getConstraints_, getConstraintsUnsafe, getConstraintsUnchecked,
+        js_states, states, states_, statesUnsafe, statesUnchecked,
+        js_getCapabilities, getCapabilities, getCapabilities_,
+        getCapabilitiesUnsafe, getCapabilitiesUnchecked,
+        js_applyConstraints, applyConstraints, js_clone, clone, clone_,
+        cloneUnsafe, cloneUnchecked, js_stop, stop, js_getKind, getKind,
+        js_getId, getId, js_getLabel, getLabel, js_setEnabled, setEnabled,
+        js_getEnabled, getEnabled, js_getMuted, getMuted, mute, unmute,
+        js_get_readonly, get_readonly, js_getRemote, getRemote,
+        js_getReadyState, getReadyState, started, ended, overConstrained,
+        MediaStreamTrack(..), gTypeMediaStreamTrack, IsMediaStreamTrack,
+        toMediaStreamTrack)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -28,6 +36,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"getSources\"]($2)"
         js_getSources ::
@@ -62,6 +80,16 @@
   = liftIO (void (js_getConstraints (toMediaStreamTrack self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/MediaStreamTrack.getConstraints Mozilla MediaStreamTrack.getConstraints documentation> 
+getConstraintsUnsafe ::
+                     (MonadIO m, IsMediaStreamTrack self, HasCallStack) =>
+                       self -> m MediaTrackConstraints
+getConstraintsUnsafe self
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_getConstraints (toMediaStreamTrack self)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/MediaStreamTrack.getConstraints Mozilla MediaStreamTrack.getConstraints documentation> 
 getConstraintsUnchecked ::
                         (MonadIO m, IsMediaStreamTrack self) =>
                           self -> m MediaTrackConstraints
@@ -86,6 +114,15 @@
 states_ self = liftIO (void (js_states (toMediaStreamTrack self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/MediaStreamTrack.states Mozilla MediaStreamTrack.states documentation> 
+statesUnsafe ::
+             (MonadIO m, IsMediaStreamTrack self, HasCallStack) =>
+               self -> m MediaSourceStates
+statesUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_states (toMediaStreamTrack self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/MediaStreamTrack.states Mozilla MediaStreamTrack.states documentation> 
 statesUnchecked ::
                 (MonadIO m, IsMediaStreamTrack self) => self -> m MediaSourceStates
 statesUnchecked self
@@ -113,6 +150,16 @@
   = liftIO (void (js_getCapabilities (toMediaStreamTrack self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/MediaStreamTrack.getCapabilities Mozilla MediaStreamTrack.getCapabilities documentation> 
+getCapabilitiesUnsafe ::
+                      (MonadIO m, IsMediaStreamTrack self, HasCallStack) =>
+                        self -> m MediaStreamCapabilities
+getCapabilitiesUnsafe self
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_getCapabilities (toMediaStreamTrack self)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/MediaStreamTrack.getCapabilities Mozilla MediaStreamTrack.getCapabilities documentation> 
 getCapabilitiesUnchecked ::
                          (MonadIO m, IsMediaStreamTrack self) =>
                            self -> m MediaStreamCapabilities
@@ -147,6 +194,15 @@
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/MediaStreamTrack.clone Mozilla MediaStreamTrack.clone documentation> 
 clone_ :: (MonadIO m, IsMediaStreamTrack self) => self -> m ()
 clone_ self = liftIO (void (js_clone (toMediaStreamTrack self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/MediaStreamTrack.clone Mozilla MediaStreamTrack.clone documentation> 
+cloneUnsafe ::
+            (MonadIO m, IsMediaStreamTrack self, HasCallStack) =>
+              self -> m MediaStreamTrack
+cloneUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_clone (toMediaStreamTrack self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/MediaStreamTrack.clone Mozilla MediaStreamTrack.clone documentation> 
 cloneUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/MediaStreamTrackEvent.hs b/src/GHCJS/DOM/JSFFI/Generated/MediaStreamTrackEvent.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/MediaStreamTrackEvent.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/MediaStreamTrackEvent.hs
@@ -1,9 +1,15 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.MediaStreamTrackEvent
-       (js_getTrack, getTrack, getTrackUnchecked, MediaStreamTrackEvent,
-        castToMediaStreamTrackEvent, gTypeMediaStreamTrackEvent)
+       (js_getTrack, getTrack, getTrackUnsafe, getTrackUnchecked,
+        MediaStreamTrackEvent(..), gTypeMediaStreamTrackEvent)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -19,6 +25,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"track\"]" js_getTrack ::
         MediaStreamTrackEvent -> IO (Nullable MediaStreamTrack)
@@ -27,6 +43,15 @@
 getTrack ::
          (MonadIO m) => MediaStreamTrackEvent -> m (Maybe MediaStreamTrack)
 getTrack self = liftIO (nullableToMaybe <$> (js_getTrack (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/MediaStreamTrackEvent.track Mozilla MediaStreamTrackEvent.track documentation> 
+getTrackUnsafe ::
+               (MonadIO m, HasCallStack) =>
+                 MediaStreamTrackEvent -> m MediaStreamTrack
+getTrackUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getTrack (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/MediaStreamTrackEvent.track Mozilla MediaStreamTrackEvent.track documentation> 
 getTrackUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/MediaStreamTrackSourcesCallback.hs b/src/GHCJS/DOM/JSFFI/Generated/MediaStreamTrackSourcesCallback.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/MediaStreamTrackSourcesCallback.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/MediaStreamTrackSourcesCallback.hs
@@ -1,4 +1,9 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.MediaStreamTrackSourcesCallback
        (newMediaStreamTrackSourcesCallback,
         newMediaStreamTrackSourcesCallbackSync,
@@ -6,6 +11,7 @@
         MediaStreamTrackSourcesCallback)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -21,6 +27,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/MediaStreamTrackSourcesCallback Mozilla MediaStreamTrackSourcesCallback documentation> 
 newMediaStreamTrackSourcesCallback ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/MediaTrackConstraints.hs b/src/GHCJS/DOM/JSFFI/Generated/MediaTrackConstraints.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/MediaTrackConstraints.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/MediaTrackConstraints.hs
@@ -1,10 +1,16 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.MediaTrackConstraints
-       (js_getMandatory, getMandatory, getMandatoryUnchecked,
-        js_getOptional, getOptional, MediaTrackConstraints,
-        castToMediaTrackConstraints, gTypeMediaTrackConstraints)
+       (js_getMandatory, getMandatory, getMandatoryUnsafe,
+        getMandatoryUnchecked, js_getOptional, getOptional,
+        MediaTrackConstraints(..), gTypeMediaTrackConstraints)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -20,6 +26,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"mandatory\"]"
         js_getMandatory :: MediaTrackConstraints -> IO JSVal
@@ -30,6 +46,15 @@
                MediaTrackConstraints -> m (Maybe MediaTrackConstraintSet)
 getMandatory self
   = liftIO ((js_getMandatory (self)) >>= fromJSValUnchecked)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/MediaTrackConstraints.mandatory Mozilla MediaTrackConstraints.mandatory documentation> 
+getMandatoryUnsafe ::
+                   (MonadIO m, HasCallStack) =>
+                     MediaTrackConstraints -> m MediaTrackConstraintSet
+getMandatoryUnsafe self
+  = liftIO
+      (((js_getMandatory (self)) >>= fromJSValUnchecked) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/MediaTrackConstraints.mandatory Mozilla MediaTrackConstraints.mandatory documentation> 
 getMandatoryUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/MemoryInfo.hs b/src/GHCJS/DOM/JSFFI/Generated/MemoryInfo.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/MemoryInfo.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/MemoryInfo.hs
@@ -1,9 +1,15 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.MemoryInfo
        (js_getUsedJSHeapSize, getUsedJSHeapSize, js_getTotalJSHeapSize,
-        getTotalJSHeapSize, MemoryInfo, castToMemoryInfo, gTypeMemoryInfo)
+        getTotalJSHeapSize, MemoryInfo(..), gTypeMemoryInfo)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -19,6 +25,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"usedJSHeapSize\"]"
         js_getUsedJSHeapSize :: MemoryInfo -> IO Word
diff --git a/src/GHCJS/DOM/JSFFI/Generated/MessageChannel.hs b/src/GHCJS/DOM/JSFFI/Generated/MessageChannel.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/MessageChannel.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/MessageChannel.hs
@@ -1,10 +1,17 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.MessageChannel
        (js_newMessageChannel, newMessageChannel, js_getPort1, getPort1,
-        getPort1Unchecked, js_getPort2, getPort2, getPort2Unchecked,
-        MessageChannel, castToMessageChannel, gTypeMessageChannel)
+        getPort1Unsafe, getPort1Unchecked, js_getPort2, getPort2,
+        getPort2Unsafe, getPort2Unchecked, MessageChannel(..),
+        gTypeMessageChannel)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -20,6 +27,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "new window[\"MessageChannel\"]()"
         js_newMessageChannel :: IO MessageChannel
@@ -36,6 +53,14 @@
 getPort1 self = liftIO (nullableToMaybe <$> (js_getPort1 (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/MessageChannel.port1 Mozilla MessageChannel.port1 documentation> 
+getPort1Unsafe ::
+               (MonadIO m, HasCallStack) => MessageChannel -> m MessagePort
+getPort1Unsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getPort1 (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/MessageChannel.port1 Mozilla MessageChannel.port1 documentation> 
 getPort1Unchecked :: (MonadIO m) => MessageChannel -> m MessagePort
 getPort1Unchecked self
   = liftIO (fromJust . nullableToMaybe <$> (js_getPort1 (self)))
@@ -46,6 +71,14 @@
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/MessageChannel.port2 Mozilla MessageChannel.port2 documentation> 
 getPort2 :: (MonadIO m) => MessageChannel -> m (Maybe MessagePort)
 getPort2 self = liftIO (nullableToMaybe <$> (js_getPort2 (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/MessageChannel.port2 Mozilla MessageChannel.port2 documentation> 
+getPort2Unsafe ::
+               (MonadIO m, HasCallStack) => MessageChannel -> m MessagePort
+getPort2Unsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getPort2 (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/MessageChannel.port2 Mozilla MessageChannel.port2 documentation> 
 getPort2Unchecked :: (MonadIO m) => MessageChannel -> m MessagePort
diff --git a/src/GHCJS/DOM/JSFFI/Generated/MessageEvent.hs b/src/GHCJS/DOM/JSFFI/Generated/MessageEvent.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/MessageEvent.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/MessageEvent.hs
@@ -1,12 +1,18 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.MessageEvent
        (js_initMessageEvent, initMessageEvent, js_webkitInitMessageEvent,
         webkitInitMessageEvent, js_getOrigin, getOrigin, js_getLastEventId,
-        getLastEventId, js_getSource, getSource, getSourceUnchecked,
-        js_getData, getData, js_getPorts, getPorts, MessageEvent,
-        castToMessageEvent, gTypeMessageEvent)
+        getLastEventId, js_getSource, getSource, getSourceUnsafe,
+        getSourceUnchecked, js_getData, getData, js_getPorts, getPorts,
+        MessageEvent(..), gTypeMessageEvent)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -22,6 +28,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe
         "$1[\"initMessageEvent\"]($2, $3,\n$4, $5, $6, $7, $8, $9)"
@@ -110,6 +126,14 @@
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/MessageEvent.source Mozilla MessageEvent.source documentation> 
 getSource :: (MonadIO m) => MessageEvent -> m (Maybe EventTarget)
 getSource self = liftIO (nullableToMaybe <$> (js_getSource (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/MessageEvent.source Mozilla MessageEvent.source documentation> 
+getSourceUnsafe ::
+                (MonadIO m, HasCallStack) => MessageEvent -> m EventTarget
+getSourceUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getSource (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/MessageEvent.source Mozilla MessageEvent.source documentation> 
 getSourceUnchecked :: (MonadIO m) => MessageEvent -> m EventTarget
diff --git a/src/GHCJS/DOM/JSFFI/Generated/MessagePort.hs b/src/GHCJS/DOM/JSFFI/Generated/MessagePort.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/MessagePort.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/MessagePort.hs
@@ -1,9 +1,15 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.MessagePort
        (js_postMessage, postMessage, js_start, start, js_close, close,
-        message, MessagePort, castToMessagePort, gTypeMessagePort)
+        message, MessagePort(..), gTypeMessagePort)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -19,6 +25,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"postMessage\"]($2, $3)"
         js_postMessage :: MessagePort -> JSVal -> Nullable Array -> IO ()
diff --git a/src/GHCJS/DOM/JSFFI/Generated/MimeType.hs b/src/GHCJS/DOM/JSFFI/Generated/MimeType.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/MimeType.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/MimeType.hs
@@ -1,11 +1,17 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.MimeType
        (js_getType, getType, js_getSuffixes, getSuffixes,
         js_getDescription, getDescription, js_getEnabledPlugin,
-        getEnabledPlugin, getEnabledPluginUnchecked, MimeType,
-        castToMimeType, gTypeMimeType)
+        getEnabledPlugin, getEnabledPluginUnsafe,
+        getEnabledPluginUnchecked, MimeType(..), gTypeMimeType)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -21,6 +27,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"type\"]" js_getType ::
         MimeType -> IO JSString
@@ -54,6 +70,14 @@
 getEnabledPlugin :: (MonadIO m) => MimeType -> m (Maybe Plugin)
 getEnabledPlugin self
   = liftIO (nullableToMaybe <$> (js_getEnabledPlugin (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/MimeType.enabledPlugin Mozilla MimeType.enabledPlugin documentation> 
+getEnabledPluginUnsafe ::
+                       (MonadIO m, HasCallStack) => MimeType -> m Plugin
+getEnabledPluginUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getEnabledPlugin (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/MimeType.enabledPlugin Mozilla MimeType.enabledPlugin documentation> 
 getEnabledPluginUnchecked :: (MonadIO m) => MimeType -> m Plugin
diff --git a/src/GHCJS/DOM/JSFFI/Generated/MimeTypeArray.hs b/src/GHCJS/DOM/JSFFI/Generated/MimeTypeArray.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/MimeTypeArray.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/MimeTypeArray.hs
@@ -1,10 +1,16 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.MimeTypeArray
-       (js_item, item, item_, itemUnchecked, js_namedItem, namedItem,
-        namedItem_, namedItemUnchecked, js_getLength, getLength,
-        MimeTypeArray, castToMimeTypeArray, gTypeMimeTypeArray)
+       (js_item, item, item_, itemUnsafe, itemUnchecked, js_namedItem,
+        namedItem, namedItem_, namedItemUnsafe, namedItemUnchecked,
+        js_getLength, getLength, MimeTypeArray(..), gTypeMimeTypeArray)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -20,6 +26,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"item\"]($2)" js_item ::
         MimeTypeArray -> Word -> IO (Nullable MimeType)
@@ -34,6 +50,14 @@
 item_ self index = liftIO (void (js_item (self) index))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/MimeTypeArray.item Mozilla MimeTypeArray.item documentation> 
+itemUnsafe ::
+           (MonadIO m, HasCallStack) => MimeTypeArray -> Word -> m MimeType
+itemUnsafe self index
+  = liftIO
+      ((nullableToMaybe <$> (js_item (self) index)) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/MimeTypeArray.item Mozilla MimeTypeArray.item documentation> 
 itemUnchecked :: (MonadIO m) => MimeTypeArray -> Word -> m MimeType
 itemUnchecked self index
   = liftIO (fromJust . nullableToMaybe <$> (js_item (self) index))
@@ -54,6 +78,15 @@
            (MonadIO m, ToJSString name) => MimeTypeArray -> name -> m ()
 namedItem_ self name
   = liftIO (void (js_namedItem (self) (toJSString name)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/MimeTypeArray.namedItem Mozilla MimeTypeArray.namedItem documentation> 
+namedItemUnsafe ::
+                (MonadIO m, ToJSString name, HasCallStack) =>
+                  MimeTypeArray -> name -> m MimeType
+namedItemUnsafe self name
+  = liftIO
+      ((nullableToMaybe <$> (js_namedItem (self) (toJSString name))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/MimeTypeArray.namedItem Mozilla MimeTypeArray.namedItem documentation> 
 namedItemUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/MouseEvent.hs b/src/GHCJS/DOM/JSFFI/Generated/MouseEvent.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/MouseEvent.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/MouseEvent.hs
@@ -1,20 +1,27 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.MouseEvent
        (js_initMouseEvent, initMouseEvent, js_getScreenX, getScreenX,
         js_getScreenY, getScreenY, js_getClientX, getClientX,
         js_getClientY, getClientY, js_getCtrlKey, getCtrlKey,
         js_getShiftKey, getShiftKey, js_getAltKey, getAltKey,
         js_getMetaKey, getMetaKey, js_getButton, getButton,
-        js_getRelatedTarget, getRelatedTarget, getRelatedTargetUnchecked,
-        js_getMovementX, getMovementX, js_getMovementY, getMovementY,
-        js_getOffsetX, getOffsetX, js_getOffsetY, getOffsetY, js_getX,
-        getX, js_getY, getY, js_getFromElement, getFromElement,
+        js_getRelatedTarget, getRelatedTarget, getRelatedTargetUnsafe,
+        getRelatedTargetUnchecked, js_getMovementX, getMovementX,
+        js_getMovementY, getMovementY, js_getOffsetX, getOffsetX,
+        js_getOffsetY, getOffsetY, js_getX, getX, js_getY, getY,
+        js_getFromElement, getFromElement, getFromElementUnsafe,
         getFromElementUnchecked, js_getToElement, getToElement,
-        getToElementUnchecked, js_getDataTransfer, getDataTransfer,
-        getDataTransferUnchecked, MouseEvent, castToMouseEvent,
-        gTypeMouseEvent, IsMouseEvent, toMouseEvent)
+        getToElementUnsafe, getToElementUnchecked, js_getDataTransfer,
+        getDataTransfer, getDataTransferUnsafe, getDataTransferUnchecked,
+        MouseEvent(..), gTypeMouseEvent, IsMouseEvent, toMouseEvent)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -29,6 +36,16 @@
 import GHCJS.DOM.Types
 import Control.Applicative ((<$>))
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe
         "$1[\"initMouseEvent\"]($2, $3, $4,\n$5, $6, $7, $8, $9, $10, $11,\n$12, $13, $14, $15, $16)"
@@ -155,6 +172,15 @@
       (nullableToMaybe <$> (js_getRelatedTarget (toMouseEvent self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/MouseEvent.relatedTarget Mozilla MouseEvent.relatedTarget documentation> 
+getRelatedTargetUnsafe ::
+                       (MonadIO m, IsMouseEvent self, HasCallStack) =>
+                         self -> m EventTarget
+getRelatedTargetUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getRelatedTarget (toMouseEvent self)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/MouseEvent.relatedTarget Mozilla MouseEvent.relatedTarget documentation> 
 getRelatedTargetUnchecked ::
                           (MonadIO m, IsMouseEvent self) => self -> m EventTarget
 getRelatedTargetUnchecked self
@@ -215,6 +241,14 @@
       (nullableToMaybe <$> (js_getFromElement (toMouseEvent self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/MouseEvent.fromElement Mozilla MouseEvent.fromElement documentation> 
+getFromElementUnsafe ::
+                     (MonadIO m, IsMouseEvent self, HasCallStack) => self -> m Node
+getFromElementUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getFromElement (toMouseEvent self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/MouseEvent.fromElement Mozilla MouseEvent.fromElement documentation> 
 getFromElementUnchecked ::
                         (MonadIO m, IsMouseEvent self) => self -> m Node
 getFromElementUnchecked self
@@ -233,6 +267,14 @@
       (nullableToMaybe <$> (js_getToElement (toMouseEvent self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/MouseEvent.toElement Mozilla MouseEvent.toElement documentation> 
+getToElementUnsafe ::
+                   (MonadIO m, IsMouseEvent self, HasCallStack) => self -> m Node
+getToElementUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getToElement (toMouseEvent self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/MouseEvent.toElement Mozilla MouseEvent.toElement documentation> 
 getToElementUnchecked ::
                       (MonadIO m, IsMouseEvent self) => self -> m Node
 getToElementUnchecked self
@@ -249,6 +291,15 @@
 getDataTransfer self
   = liftIO
       (nullableToMaybe <$> (js_getDataTransfer (toMouseEvent self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/MouseEvent.dataTransfer Mozilla MouseEvent.dataTransfer documentation> 
+getDataTransferUnsafe ::
+                      (MonadIO m, IsMouseEvent self, HasCallStack) =>
+                        self -> m DataTransfer
+getDataTransferUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getDataTransfer (toMouseEvent self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/MouseEvent.dataTransfer Mozilla MouseEvent.dataTransfer documentation> 
 getDataTransferUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/MutationEvent.hs b/src/GHCJS/DOM/JSFFI/Generated/MutationEvent.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/MutationEvent.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/MutationEvent.hs
@@ -1,13 +1,19 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.MutationEvent
        (js_initMutationEvent, initMutationEvent, pattern MODIFICATION,
         pattern ADDITION, pattern REMOVAL, js_getRelatedNode,
-        getRelatedNode, getRelatedNodeUnchecked, js_getPrevValue,
-        getPrevValue, js_getNewValue, getNewValue, js_getAttrName,
-        getAttrName, js_getAttrChange, getAttrChange, MutationEvent,
-        castToMutationEvent, gTypeMutationEvent)
+        getRelatedNode, getRelatedNodeUnsafe, getRelatedNodeUnchecked,
+        js_getPrevValue, getPrevValue, js_getNewValue, getNewValue,
+        js_getAttrName, getAttrName, js_getAttrChange, getAttrChange,
+        MutationEvent(..), gTypeMutationEvent)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -23,6 +29,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe
         "$1[\"initMutationEvent\"]($2, $3,\n$4, $5, $6, $7, $8, $9)"
@@ -64,6 +80,14 @@
 getRelatedNode :: (MonadIO m) => MutationEvent -> m (Maybe Node)
 getRelatedNode self
   = liftIO (nullableToMaybe <$> (js_getRelatedNode (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/MutationEvent.relatedNode Mozilla MutationEvent.relatedNode documentation> 
+getRelatedNodeUnsafe ::
+                     (MonadIO m, HasCallStack) => MutationEvent -> m Node
+getRelatedNodeUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getRelatedNode (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/MutationEvent.relatedNode Mozilla MutationEvent.relatedNode documentation> 
 getRelatedNodeUnchecked :: (MonadIO m) => MutationEvent -> m Node
diff --git a/src/GHCJS/DOM/JSFFI/Generated/MutationObserver.hs b/src/GHCJS/DOM/JSFFI/Generated/MutationObserver.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/MutationObserver.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/MutationObserver.hs
@@ -1,11 +1,16 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.MutationObserver
        (js_newMutationObserver, newMutationObserver, js_observe, observe,
         js_takeRecords, takeRecords, takeRecords_, js_disconnect,
-        disconnect, MutationObserver, castToMutationObserver,
-        gTypeMutationObserver)
+        disconnect, MutationObserver(..), gTypeMutationObserver)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -21,6 +26,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe
         "new window[\"MutationObserver\"]($1)" js_newMutationObserver ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/MutationRecord.hs b/src/GHCJS/DOM/JSFFI/Generated/MutationRecord.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/MutationRecord.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/MutationRecord.hs
@@ -1,17 +1,26 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.MutationRecord
-       (js_getType, getType, js_getTarget, getTarget, getTargetUnchecked,
-        js_getAddedNodes, getAddedNodes, getAddedNodesUnchecked,
-        js_getRemovedNodes, getRemovedNodes, getRemovedNodesUnchecked,
+       (js_getType, getType, js_getTarget, getTarget, getTargetUnsafe,
+        getTargetUnchecked, js_getAddedNodes, getAddedNodes,
+        getAddedNodesUnsafe, getAddedNodesUnchecked, js_getRemovedNodes,
+        getRemovedNodes, getRemovedNodesUnsafe, getRemovedNodesUnchecked,
         js_getPreviousSibling, getPreviousSibling,
-        getPreviousSiblingUnchecked, js_getNextSibling, getNextSibling,
+        getPreviousSiblingUnsafe, getPreviousSiblingUnchecked,
+        js_getNextSibling, getNextSibling, getNextSiblingUnsafe,
         getNextSiblingUnchecked, js_getAttributeName, getAttributeName,
-        getAttributeNameUnchecked, js_getAttributeNamespace,
-        getAttributeNamespace, getAttributeNamespaceUnchecked,
-        js_getOldValue, getOldValue, getOldValueUnchecked, MutationRecord,
-        castToMutationRecord, gTypeMutationRecord)
+        getAttributeNameUnsafe, getAttributeNameUnchecked,
+        js_getAttributeNamespace, getAttributeNamespace,
+        getAttributeNamespaceUnsafe, getAttributeNamespaceUnchecked,
+        js_getOldValue, getOldValue, getOldValueUnsafe,
+        getOldValueUnchecked, MutationRecord(..), gTypeMutationRecord)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -27,6 +36,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"type\"]" js_getType ::
         MutationRecord -> IO JSString
@@ -44,6 +63,14 @@
 getTarget self = liftIO (nullableToMaybe <$> (js_getTarget (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/MutationRecord.target Mozilla MutationRecord.target documentation> 
+getTargetUnsafe ::
+                (MonadIO m, HasCallStack) => MutationRecord -> m Node
+getTargetUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getTarget (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/MutationRecord.target Mozilla MutationRecord.target documentation> 
 getTargetUnchecked :: (MonadIO m) => MutationRecord -> m Node
 getTargetUnchecked self
   = liftIO (fromJust . nullableToMaybe <$> (js_getTarget (self)))
@@ -58,6 +85,14 @@
   = liftIO (nullableToMaybe <$> (js_getAddedNodes (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/MutationRecord.addedNodes Mozilla MutationRecord.addedNodes documentation> 
+getAddedNodesUnsafe ::
+                    (MonadIO m, HasCallStack) => MutationRecord -> m NodeList
+getAddedNodesUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getAddedNodes (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/MutationRecord.addedNodes Mozilla MutationRecord.addedNodes documentation> 
 getAddedNodesUnchecked ::
                        (MonadIO m) => MutationRecord -> m NodeList
 getAddedNodesUnchecked self
@@ -73,6 +108,14 @@
   = liftIO (nullableToMaybe <$> (js_getRemovedNodes (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/MutationRecord.removedNodes Mozilla MutationRecord.removedNodes documentation> 
+getRemovedNodesUnsafe ::
+                      (MonadIO m, HasCallStack) => MutationRecord -> m NodeList
+getRemovedNodesUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getRemovedNodes (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/MutationRecord.removedNodes Mozilla MutationRecord.removedNodes documentation> 
 getRemovedNodesUnchecked ::
                          (MonadIO m) => MutationRecord -> m NodeList
 getRemovedNodesUnchecked self
@@ -89,6 +132,14 @@
   = liftIO (nullableToMaybe <$> (js_getPreviousSibling (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/MutationRecord.previousSibling Mozilla MutationRecord.previousSibling documentation> 
+getPreviousSiblingUnsafe ::
+                         (MonadIO m, HasCallStack) => MutationRecord -> m Node
+getPreviousSiblingUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getPreviousSibling (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/MutationRecord.previousSibling Mozilla MutationRecord.previousSibling documentation> 
 getPreviousSiblingUnchecked ::
                             (MonadIO m) => MutationRecord -> m Node
 getPreviousSiblingUnchecked self
@@ -104,6 +155,14 @@
   = liftIO (nullableToMaybe <$> (js_getNextSibling (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/MutationRecord.nextSibling Mozilla MutationRecord.nextSibling documentation> 
+getNextSiblingUnsafe ::
+                     (MonadIO m, HasCallStack) => MutationRecord -> m Node
+getNextSiblingUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getNextSibling (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/MutationRecord.nextSibling Mozilla MutationRecord.nextSibling documentation> 
 getNextSiblingUnchecked :: (MonadIO m) => MutationRecord -> m Node
 getNextSiblingUnchecked self
   = liftIO
@@ -120,6 +179,15 @@
   = liftIO (fromMaybeJSString <$> (js_getAttributeName (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/MutationRecord.attributeName Mozilla MutationRecord.attributeName documentation> 
+getAttributeNameUnsafe ::
+                       (MonadIO m, HasCallStack, FromJSString result) =>
+                         MutationRecord -> m result
+getAttributeNameUnsafe self
+  = liftIO
+      ((fromMaybeJSString <$> (js_getAttributeName (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/MutationRecord.attributeName Mozilla MutationRecord.attributeName documentation> 
 getAttributeNameUnchecked ::
                           (MonadIO m, FromJSString result) => MutationRecord -> m result
 getAttributeNameUnchecked self
@@ -138,6 +206,15 @@
   = liftIO (fromMaybeJSString <$> (js_getAttributeNamespace (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/MutationRecord.attributeNamespace Mozilla MutationRecord.attributeNamespace documentation> 
+getAttributeNamespaceUnsafe ::
+                            (MonadIO m, HasCallStack, FromJSString result) =>
+                              MutationRecord -> m result
+getAttributeNamespaceUnsafe self
+  = liftIO
+      ((fromMaybeJSString <$> (js_getAttributeNamespace (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/MutationRecord.attributeNamespace Mozilla MutationRecord.attributeNamespace documentation> 
 getAttributeNamespaceUnchecked ::
                                (MonadIO m, FromJSString result) => MutationRecord -> m result
 getAttributeNamespaceUnchecked self
@@ -154,6 +231,15 @@
               MutationRecord -> m (Maybe result)
 getOldValue self
   = liftIO (fromMaybeJSString <$> (js_getOldValue (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/MutationRecord.oldValue Mozilla MutationRecord.oldValue documentation> 
+getOldValueUnsafe ::
+                  (MonadIO m, HasCallStack, FromJSString result) =>
+                    MutationRecord -> m result
+getOldValueUnsafe self
+  = liftIO
+      ((fromMaybeJSString <$> (js_getOldValue (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/MutationRecord.oldValue Mozilla MutationRecord.oldValue documentation> 
 getOldValueUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/NamedNodeMap.hs b/src/GHCJS/DOM/JSFFI/Generated/NamedNodeMap.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/NamedNodeMap.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/NamedNodeMap.hs
@@ -1,17 +1,25 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.NamedNodeMap
-       (js_getNamedItem, getNamedItem, getNamedItem_,
+       (js_getNamedItem, getNamedItem, getNamedItem_, getNamedItemUnsafe,
         getNamedItemUnchecked, js_setNamedItem, setNamedItem,
-        setNamedItem_, setNamedItemUnchecked, js_removeNamedItem,
-        removeNamedItem, removeNamedItem_, removeNamedItemUnchecked,
-        js_item, item, item_, itemUnchecked, js_getNamedItemNS,
-        getNamedItemNS, getNamedItemNS_, getNamedItemNSUnchecked,
-        js_setNamedItemNS, setNamedItemNS, setNamedItemNS_,
-        setNamedItemNSUnchecked, js_removeNamedItemNS, removeNamedItemNS,
-        removeNamedItemNS_, removeNamedItemNSUnchecked, js_getLength,
-        getLength, NamedNodeMap, castToNamedNodeMap, gTypeNamedNodeMap)
+        setNamedItem_, setNamedItemUnsafe, setNamedItemUnchecked,
+        js_removeNamedItem, removeNamedItem, removeNamedItem_,
+        removeNamedItemUnsafe, removeNamedItemUnchecked, js_item, item,
+        item_, itemUnsafe, itemUnchecked, js_getNamedItemNS,
+        getNamedItemNS, getNamedItemNS_, getNamedItemNSUnsafe,
+        getNamedItemNSUnchecked, js_setNamedItemNS, setNamedItemNS,
+        setNamedItemNS_, setNamedItemNSUnsafe, setNamedItemNSUnchecked,
+        js_removeNamedItemNS, removeNamedItemNS, removeNamedItemNS_,
+        removeNamedItemNSUnsafe, removeNamedItemNSUnchecked, js_getLength,
+        getLength, NamedNodeMap(..), gTypeNamedNodeMap)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -27,6 +35,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"getNamedItem\"]($2)"
         js_getNamedItem :: NamedNodeMap -> JSString -> IO (Nullable Node)
@@ -46,6 +64,15 @@
   = liftIO (void (js_getNamedItem (self) (toJSString name)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/NamedNodeMap.getNamedItem Mozilla NamedNodeMap.getNamedItem documentation> 
+getNamedItemUnsafe ::
+                   (MonadIO m, ToJSString name, HasCallStack) =>
+                     NamedNodeMap -> name -> m Node
+getNamedItemUnsafe self name
+  = liftIO
+      ((nullableToMaybe <$> (js_getNamedItem (self) (toJSString name)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/NamedNodeMap.getNamedItem Mozilla NamedNodeMap.getNamedItem documentation> 
 getNamedItemUnchecked ::
                       (MonadIO m, ToJSString name) => NamedNodeMap -> name -> m Node
 getNamedItemUnchecked self name
@@ -75,6 +102,16 @@
          (js_setNamedItem (self) (maybeToNullable (fmap toNode node))))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/NamedNodeMap.setNamedItem Mozilla NamedNodeMap.setNamedItem documentation> 
+setNamedItemUnsafe ::
+                   (MonadIO m, IsNode node, HasCallStack) =>
+                     NamedNodeMap -> Maybe node -> m Node
+setNamedItemUnsafe self node
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_setNamedItem (self) (maybeToNullable (fmap toNode node))))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/NamedNodeMap.setNamedItem Mozilla NamedNodeMap.setNamedItem documentation> 
 setNamedItemUnchecked ::
                       (MonadIO m, IsNode node) => NamedNodeMap -> Maybe node -> m Node
 setNamedItemUnchecked self node
@@ -101,6 +138,16 @@
   = liftIO (void (js_removeNamedItem (self) (toJSString name)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/NamedNodeMap.removeNamedItem Mozilla NamedNodeMap.removeNamedItem documentation> 
+removeNamedItemUnsafe ::
+                      (MonadIO m, ToJSString name, HasCallStack) =>
+                        NamedNodeMap -> name -> m Node
+removeNamedItemUnsafe self name
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_removeNamedItem (self) (toJSString name)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/NamedNodeMap.removeNamedItem Mozilla NamedNodeMap.removeNamedItem documentation> 
 removeNamedItemUnchecked ::
                          (MonadIO m, ToJSString name) => NamedNodeMap -> name -> m Node
 removeNamedItemUnchecked self name
@@ -121,6 +168,14 @@
 item_ self index = liftIO (void (js_item (self) index))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/NamedNodeMap.item Mozilla NamedNodeMap.item documentation> 
+itemUnsafe ::
+           (MonadIO m, HasCallStack) => NamedNodeMap -> Word -> m Node
+itemUnsafe self index
+  = liftIO
+      ((nullableToMaybe <$> (js_item (self) index)) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/NamedNodeMap.item Mozilla NamedNodeMap.item documentation> 
 itemUnchecked :: (MonadIO m) => NamedNodeMap -> Word -> m Node
 itemUnchecked self index
   = liftIO (fromJust . nullableToMaybe <$> (js_item (self) index))
@@ -150,6 +205,18 @@
             (toJSString localName)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/NamedNodeMap.getNamedItemNS Mozilla NamedNodeMap.getNamedItemNS documentation> 
+getNamedItemNSUnsafe ::
+                     (MonadIO m, ToJSString namespaceURI, ToJSString localName,
+                      HasCallStack) =>
+                       NamedNodeMap -> Maybe namespaceURI -> localName -> m Node
+getNamedItemNSUnsafe self namespaceURI localName
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_getNamedItemNS (self) (toMaybeJSString namespaceURI)
+             (toJSString localName)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/NamedNodeMap.getNamedItemNS Mozilla NamedNodeMap.getNamedItemNS documentation> 
 getNamedItemNSUnchecked ::
                         (MonadIO m, ToJSString namespaceURI, ToJSString localName) =>
                           NamedNodeMap -> Maybe namespaceURI -> localName -> m Node
@@ -181,6 +248,16 @@
          (js_setNamedItemNS (self) (maybeToNullable (fmap toNode node))))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/NamedNodeMap.setNamedItemNS Mozilla NamedNodeMap.setNamedItemNS documentation> 
+setNamedItemNSUnsafe ::
+                     (MonadIO m, IsNode node, HasCallStack) =>
+                       NamedNodeMap -> Maybe node -> m Node
+setNamedItemNSUnsafe self node
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_setNamedItemNS (self) (maybeToNullable (fmap toNode node))))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/NamedNodeMap.setNamedItemNS Mozilla NamedNodeMap.setNamedItemNS documentation> 
 setNamedItemNSUnchecked ::
                         (MonadIO m, IsNode node) => NamedNodeMap -> Maybe node -> m Node
 setNamedItemNSUnchecked self node
@@ -211,6 +288,18 @@
       (void
          (js_removeNamedItemNS (self) (toMaybeJSString namespaceURI)
             (toJSString localName)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/NamedNodeMap.removeNamedItemNS Mozilla NamedNodeMap.removeNamedItemNS documentation> 
+removeNamedItemNSUnsafe ::
+                        (MonadIO m, ToJSString namespaceURI, ToJSString localName,
+                         HasCallStack) =>
+                          NamedNodeMap -> Maybe namespaceURI -> localName -> m Node
+removeNamedItemNSUnsafe self namespaceURI localName
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_removeNamedItemNS (self) (toMaybeJSString namespaceURI)
+             (toJSString localName)))
+         >>= maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/NamedNodeMap.removeNamedItemNS Mozilla NamedNodeMap.removeNamedItemNS documentation> 
 removeNamedItemNSUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/Navigator.hs b/src/GHCJS/DOM/JSFFI/Generated/Navigator.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/Navigator.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/Navigator.hs
@@ -1,4 +1,9 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.Navigator
        (js_getGamepads, getGamepads, getGamepads_, js_webkitGetUserMedia,
         webkitGetUserMedia, js_registerProtocolHandler,
@@ -8,23 +13,27 @@
         js_vibratePattern, vibratePattern, vibratePattern_, js_vibrate,
         vibrate, vibrate_, js_javaEnabled, javaEnabled, javaEnabled_,
         js_getStorageUpdates, getStorageUpdates, js_getWebkitBattery,
-        getWebkitBattery, getWebkitBatteryUnchecked, js_getGeolocation,
-        getGeolocation, getGeolocationUnchecked,
+        getWebkitBattery, getWebkitBatteryUnsafe,
+        getWebkitBatteryUnchecked, js_getGeolocation, getGeolocation,
+        getGeolocationUnsafe, getGeolocationUnchecked,
         js_getWebkitTemporaryStorage, getWebkitTemporaryStorage,
+        getWebkitTemporaryStorageUnsafe,
         getWebkitTemporaryStorageUnchecked, js_getWebkitPersistentStorage,
-        getWebkitPersistentStorage, getWebkitPersistentStorageUnchecked,
-        js_getAppCodeName, getAppCodeName, js_getAppName, getAppName,
-        js_getAppVersion, getAppVersion, js_getLanguage, getLanguage,
-        js_getUserAgent, getUserAgent, js_getPlatform, getPlatform,
-        js_getPlugins, getPlugins, getPluginsUnchecked, js_getMimeTypes,
-        getMimeTypes, getMimeTypesUnchecked, js_getProduct, getProduct,
-        js_getProductSub, getProductSub, js_getVendor, getVendor,
-        js_getVendorSub, getVendorSub, js_getCookieEnabled,
-        getCookieEnabled, js_getOnLine, getOnLine,
-        js_getHardwareConcurrency, getHardwareConcurrency, Navigator,
-        castToNavigator, gTypeNavigator)
+        getWebkitPersistentStorage, getWebkitPersistentStorageUnsafe,
+        getWebkitPersistentStorageUnchecked, js_getAppCodeName,
+        getAppCodeName, js_getAppName, getAppName, js_getAppVersion,
+        getAppVersion, js_getLanguage, getLanguage, js_getUserAgent,
+        getUserAgent, js_getPlatform, getPlatform, js_getPlugins,
+        getPlugins, getPluginsUnsafe, getPluginsUnchecked, js_getMimeTypes,
+        getMimeTypes, getMimeTypesUnsafe, getMimeTypesUnchecked,
+        js_getProduct, getProduct, js_getProductSub, getProductSub,
+        js_getVendor, getVendor, js_getVendorSub, getVendorSub,
+        js_getCookieEnabled, getCookieEnabled, js_getOnLine, getOnLine,
+        js_getHardwareConcurrency, getHardwareConcurrency, Navigator(..),
+        gTypeNavigator)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -40,6 +49,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"getGamepads\"]()"
         js_getGamepads :: Navigator -> IO JSVal
@@ -186,6 +205,14 @@
   = liftIO (nullableToMaybe <$> (js_getWebkitBattery (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Navigator.webkitBattery Mozilla Navigator.webkitBattery documentation> 
+getWebkitBatteryUnsafe ::
+                       (MonadIO m, HasCallStack) => Navigator -> m BatteryManager
+getWebkitBatteryUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getWebkitBattery (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Navigator.webkitBattery Mozilla Navigator.webkitBattery documentation> 
 getWebkitBatteryUnchecked ::
                           (MonadIO m) => Navigator -> m BatteryManager
 getWebkitBatteryUnchecked self
@@ -201,6 +228,14 @@
   = liftIO (nullableToMaybe <$> (js_getGeolocation (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Navigator.geolocation Mozilla Navigator.geolocation documentation> 
+getGeolocationUnsafe ::
+                     (MonadIO m, HasCallStack) => Navigator -> m Geolocation
+getGeolocationUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getGeolocation (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Navigator.geolocation Mozilla Navigator.geolocation documentation> 
 getGeolocationUnchecked ::
                         (MonadIO m) => Navigator -> m Geolocation
 getGeolocationUnchecked self
@@ -219,6 +254,14 @@
       (nullableToMaybe <$> (js_getWebkitTemporaryStorage (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Navigator.webkitTemporaryStorage Mozilla Navigator.webkitTemporaryStorage documentation> 
+getWebkitTemporaryStorageUnsafe ::
+                                (MonadIO m, HasCallStack) => Navigator -> m StorageQuota
+getWebkitTemporaryStorageUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getWebkitTemporaryStorage (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Navigator.webkitTemporaryStorage Mozilla Navigator.webkitTemporaryStorage documentation> 
 getWebkitTemporaryStorageUnchecked ::
                                    (MonadIO m) => Navigator -> m StorageQuota
 getWebkitTemporaryStorageUnchecked self
@@ -238,6 +281,14 @@
       (nullableToMaybe <$> (js_getWebkitPersistentStorage (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Navigator.webkitPersistentStorage Mozilla Navigator.webkitPersistentStorage documentation> 
+getWebkitPersistentStorageUnsafe ::
+                                 (MonadIO m, HasCallStack) => Navigator -> m StorageQuota
+getWebkitPersistentStorageUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getWebkitPersistentStorage (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Navigator.webkitPersistentStorage Mozilla Navigator.webkitPersistentStorage documentation> 
 getWebkitPersistentStorageUnchecked ::
                                     (MonadIO m) => Navigator -> m StorageQuota
 getWebkitPersistentStorageUnchecked self
@@ -307,6 +358,14 @@
   = liftIO (nullableToMaybe <$> (js_getPlugins (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Navigator.plugins Mozilla Navigator.plugins documentation> 
+getPluginsUnsafe ::
+                 (MonadIO m, HasCallStack) => Navigator -> m PluginArray
+getPluginsUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getPlugins (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Navigator.plugins Mozilla Navigator.plugins documentation> 
 getPluginsUnchecked :: (MonadIO m) => Navigator -> m PluginArray
 getPluginsUnchecked self
   = liftIO (fromJust . nullableToMaybe <$> (js_getPlugins (self)))
@@ -318,6 +377,14 @@
 getMimeTypes :: (MonadIO m) => Navigator -> m (Maybe MimeTypeArray)
 getMimeTypes self
   = liftIO (nullableToMaybe <$> (js_getMimeTypes (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Navigator.mimeTypes Mozilla Navigator.mimeTypes documentation> 
+getMimeTypesUnsafe ::
+                   (MonadIO m, HasCallStack) => Navigator -> m MimeTypeArray
+getMimeTypesUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getMimeTypes (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Navigator.mimeTypes Mozilla Navigator.mimeTypes documentation> 
 getMimeTypesUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/NavigatorUserMediaError.hs b/src/GHCJS/DOM/JSFFI/Generated/NavigatorUserMediaError.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/NavigatorUserMediaError.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/NavigatorUserMediaError.hs
@@ -1,9 +1,15 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.NavigatorUserMediaError
-       (js_getConstraintName, getConstraintName, NavigatorUserMediaError,
-        castToNavigatorUserMediaError, gTypeNavigatorUserMediaError)
+       (js_getConstraintName, getConstraintName,
+        NavigatorUserMediaError(..), gTypeNavigatorUserMediaError)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -19,6 +25,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"constraintName\"]"
         js_getConstraintName :: NavigatorUserMediaError -> IO JSString
diff --git a/src/GHCJS/DOM/JSFFI/Generated/NavigatorUserMediaErrorCallback.hs b/src/GHCJS/DOM/JSFFI/Generated/NavigatorUserMediaErrorCallback.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/NavigatorUserMediaErrorCallback.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/NavigatorUserMediaErrorCallback.hs
@@ -1,4 +1,9 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.NavigatorUserMediaErrorCallback
        (newNavigatorUserMediaErrorCallback,
         newNavigatorUserMediaErrorCallbackSync,
@@ -6,6 +11,7 @@
         NavigatorUserMediaErrorCallback)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -21,6 +27,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/NavigatorUserMediaErrorCallback Mozilla NavigatorUserMediaErrorCallback documentation> 
 newNavigatorUserMediaErrorCallback ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/NavigatorUserMediaSuccessCallback.hs b/src/GHCJS/DOM/JSFFI/Generated/NavigatorUserMediaSuccessCallback.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/NavigatorUserMediaSuccessCallback.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/NavigatorUserMediaSuccessCallback.hs
@@ -1,4 +1,9 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.NavigatorUserMediaSuccessCallback
        (newNavigatorUserMediaSuccessCallback,
         newNavigatorUserMediaSuccessCallbackSync,
@@ -6,6 +11,7 @@
         NavigatorUserMediaSuccessCallback)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -21,6 +27,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/NavigatorUserMediaSuccessCallback Mozilla NavigatorUserMediaSuccessCallback documentation> 
 newNavigatorUserMediaSuccessCallback ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/Node.hs b/src/GHCJS/DOM/JSFFI/Generated/Node.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/Node.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/Node.hs
@@ -1,17 +1,24 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.Node
-       (js_insertBefore, insertBefore, insertBefore_,
+       (js_insertBefore, insertBefore, insertBefore_, insertBeforeUnsafe,
         insertBeforeUnchecked, js_replaceChild, replaceChild,
-        replaceChild_, replaceChildUnchecked, js_removeChild, removeChild,
-        removeChild_, removeChildUnchecked, js_appendChild, appendChild,
-        appendChild_, appendChildUnchecked, js_hasChildNodes,
+        replaceChild_, replaceChildUnsafe, replaceChildUnchecked,
+        js_removeChild, removeChild, removeChild_, removeChildUnsafe,
+        removeChildUnchecked, js_appendChild, appendChild, appendChild_,
+        appendChildUnsafe, appendChildUnchecked, js_hasChildNodes,
         hasChildNodes, hasChildNodes_, js_cloneNode, cloneNode, cloneNode_,
-        cloneNodeUnchecked, js_normalize, normalize, js_isSupported,
-        isSupported, isSupported_, js_isSameNode, isSameNode, isSameNode_,
-        js_isEqualNode, isEqualNode, isEqualNode_, js_lookupPrefix,
-        lookupPrefix, lookupPrefix_, lookupPrefixUnchecked,
-        js_isDefaultNamespace, isDefaultNamespace, isDefaultNamespace_,
-        js_lookupNamespaceURI, lookupNamespaceURI, lookupNamespaceURI_,
+        cloneNodeUnsafe, cloneNodeUnchecked, js_normalize, normalize,
+        js_isSupported, isSupported, isSupported_, js_isSameNode,
+        isSameNode, isSameNode_, js_isEqualNode, isEqualNode, isEqualNode_,
+        js_lookupPrefix, lookupPrefix, lookupPrefix_, lookupPrefixUnsafe,
+        lookupPrefixUnchecked, js_isDefaultNamespace, isDefaultNamespace,
+        isDefaultNamespace_, js_lookupNamespaceURI, lookupNamespaceURI,
+        lookupNamespaceURI_, lookupNamespaceURIUnsafe,
         lookupNamespaceURIUnchecked, js_compareDocumentPosition,
         compareDocumentPosition, compareDocumentPosition_, js_contains,
         contains, contains_, pattern ELEMENT_NODE, pattern ATTRIBUTE_NODE,
@@ -26,25 +33,31 @@
         pattern DOCUMENT_POSITION_CONTAINS,
         pattern DOCUMENT_POSITION_CONTAINED_BY,
         pattern DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC, js_getNodeName,
-        getNodeName, getNodeNameUnchecked, js_setNodeValue, setNodeValue,
-        js_getNodeValue, getNodeValue, getNodeValueUnchecked,
-        js_getNodeType, getNodeType, js_getParentNode, getParentNode,
+        getNodeName, getNodeNameUnsafe, getNodeNameUnchecked,
+        js_setNodeValue, setNodeValue, js_getNodeValue, getNodeValue,
+        getNodeValueUnsafe, getNodeValueUnchecked, js_getNodeType,
+        getNodeType, js_getParentNode, getParentNode, getParentNodeUnsafe,
         getParentNodeUnchecked, js_getChildNodes, getChildNodes,
-        getChildNodesUnchecked, js_getFirstChild, getFirstChild,
-        getFirstChildUnchecked, js_getLastChild, getLastChild,
+        getChildNodesUnsafe, getChildNodesUnchecked, js_getFirstChild,
+        getFirstChild, getFirstChildUnsafe, getFirstChildUnchecked,
+        js_getLastChild, getLastChild, getLastChildUnsafe,
         getLastChildUnchecked, js_getPreviousSibling, getPreviousSibling,
-        getPreviousSiblingUnchecked, js_getNextSibling, getNextSibling,
+        getPreviousSiblingUnsafe, getPreviousSiblingUnchecked,
+        js_getNextSibling, getNextSibling, getNextSiblingUnsafe,
         getNextSiblingUnchecked, js_getOwnerDocument, getOwnerDocument,
-        getOwnerDocumentUnchecked, js_getNamespaceURI, getNamespaceURI,
+        getOwnerDocumentUnsafe, getOwnerDocumentUnchecked,
+        js_getNamespaceURI, getNamespaceURI, getNamespaceURIUnsafe,
         getNamespaceURIUnchecked, js_setPrefix, setPrefix, js_getPrefix,
-        getPrefix, getPrefixUnchecked, js_getLocalName, getLocalName,
-        getLocalNameUnchecked, js_getBaseURI, getBaseURI,
-        getBaseURIUnchecked, js_setTextContent, setTextContent,
-        js_getTextContent, getTextContent, getTextContentUnchecked,
-        js_getParentElement, getParentElement, getParentElementUnchecked,
-        Node, castToNode, gTypeNode, IsNode, toNode)
+        getPrefix, getPrefixUnsafe, getPrefixUnchecked, js_getLocalName,
+        getLocalName, getLocalNameUnsafe, getLocalNameUnchecked,
+        js_getBaseURI, getBaseURI, getBaseURIUnsafe, getBaseURIUnchecked,
+        js_setTextContent, setTextContent, js_getTextContent,
+        getTextContent, getTextContentUnsafe, getTextContentUnchecked,
+        js_getParentElement, getParentElement, getParentElementUnsafe,
+        getParentElementUnchecked, Node(..), gTypeNode, IsNode, toNode)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -60,6 +73,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"insertBefore\"]($2, $3)"
         js_insertBefore ::
@@ -88,6 +111,19 @@
             (maybeToNullable (fmap toNode refChild))))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Node.insertBefore Mozilla Node.insertBefore documentation> 
+insertBeforeUnsafe ::
+                   (MonadIO m, IsNode self, IsNode newChild, IsNode refChild,
+                    HasCallStack) =>
+                     self -> Maybe newChild -> Maybe refChild -> m Node
+insertBeforeUnsafe self newChild refChild
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_insertBefore (toNode self)
+             (maybeToNullable (fmap toNode newChild))
+             (maybeToNullable (fmap toNode refChild))))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Node.insertBefore Mozilla Node.insertBefore documentation> 
 insertBeforeUnchecked ::
                       (MonadIO m, IsNode self, IsNode newChild, IsNode refChild) =>
                         self -> Maybe newChild -> Maybe refChild -> m Node
@@ -125,6 +161,19 @@
             (maybeToNullable (fmap toNode oldChild))))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Node.replaceChild Mozilla Node.replaceChild documentation> 
+replaceChildUnsafe ::
+                   (MonadIO m, IsNode self, IsNode newChild, IsNode oldChild,
+                    HasCallStack) =>
+                     self -> Maybe newChild -> Maybe oldChild -> m Node
+replaceChildUnsafe self newChild oldChild
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_replaceChild (toNode self)
+             (maybeToNullable (fmap toNode newChild))
+             (maybeToNullable (fmap toNode oldChild))))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Node.replaceChild Mozilla Node.replaceChild documentation> 
 replaceChildUnchecked ::
                       (MonadIO m, IsNode self, IsNode newChild, IsNode oldChild) =>
                         self -> Maybe newChild -> Maybe oldChild -> m Node
@@ -159,6 +208,17 @@
             (maybeToNullable (fmap toNode oldChild))))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Node.removeChild Mozilla Node.removeChild documentation> 
+removeChildUnsafe ::
+                  (MonadIO m, IsNode self, IsNode oldChild, HasCallStack) =>
+                    self -> Maybe oldChild -> m Node
+removeChildUnsafe self oldChild
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_removeChild (toNode self)
+             (maybeToNullable (fmap toNode oldChild))))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Node.removeChild Mozilla Node.removeChild documentation> 
 removeChildUnchecked ::
                      (MonadIO m, IsNode self, IsNode oldChild) =>
                        self -> Maybe oldChild -> m Node
@@ -192,6 +252,17 @@
             (maybeToNullable (fmap toNode newChild))))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Node.appendChild Mozilla Node.appendChild documentation> 
+appendChildUnsafe ::
+                  (MonadIO m, IsNode self, IsNode newChild, HasCallStack) =>
+                    self -> Maybe newChild -> m Node
+appendChildUnsafe self newChild
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_appendChild (toNode self)
+             (maybeToNullable (fmap toNode newChild))))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Node.appendChild Mozilla Node.appendChild documentation> 
 appendChildUnchecked ::
                      (MonadIO m, IsNode self, IsNode newChild) =>
                        self -> Maybe newChild -> m Node
@@ -229,6 +300,14 @@
   = liftIO (void (js_cloneNode (toNode self) deep))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Node.cloneNode Mozilla Node.cloneNode documentation> 
+cloneNodeUnsafe ::
+                (MonadIO m, IsNode self, HasCallStack) => self -> Bool -> m Node
+cloneNodeUnsafe self deep
+  = liftIO
+      ((nullableToMaybe <$> (js_cloneNode (toNode self) deep)) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Node.cloneNode Mozilla Node.cloneNode documentation> 
 cloneNodeUnchecked ::
                    (MonadIO m, IsNode self) => self -> Bool -> m Node
 cloneNodeUnchecked self deep
@@ -333,6 +412,17 @@
          (js_lookupPrefix (toNode self) (toMaybeJSString namespaceURI)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Node.lookupPrefix Mozilla Node.lookupPrefix documentation> 
+lookupPrefixUnsafe ::
+                   (MonadIO m, IsNode self, ToJSString namespaceURI, HasCallStack,
+                    FromJSString result) =>
+                     self -> Maybe namespaceURI -> m result
+lookupPrefixUnsafe self namespaceURI
+  = liftIO
+      ((fromMaybeJSString <$>
+          (js_lookupPrefix (toNode self) (toMaybeJSString namespaceURI)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Node.lookupPrefix Mozilla Node.lookupPrefix documentation> 
 lookupPrefixUnchecked ::
                       (MonadIO m, IsNode self, ToJSString namespaceURI,
                        FromJSString result) =>
@@ -388,6 +478,17 @@
          (js_lookupNamespaceURI (toNode self) (toMaybeJSString prefix)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Node.lookupNamespaceURI Mozilla Node.lookupNamespaceURI documentation> 
+lookupNamespaceURIUnsafe ::
+                         (MonadIO m, IsNode self, ToJSString prefix, HasCallStack,
+                          FromJSString result) =>
+                           self -> Maybe prefix -> m result
+lookupNamespaceURIUnsafe self prefix
+  = liftIO
+      ((fromMaybeJSString <$>
+          (js_lookupNamespaceURI (toNode self) (toMaybeJSString prefix)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Node.lookupNamespaceURI Mozilla Node.lookupNamespaceURI documentation> 
 lookupNamespaceURIUnchecked ::
                             (MonadIO m, IsNode self, ToJSString prefix, FromJSString result) =>
                               self -> Maybe prefix -> m result
@@ -468,6 +569,15 @@
   = liftIO (fromMaybeJSString <$> (js_getNodeName (toNode self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Node.nodeName Mozilla Node.nodeName documentation> 
+getNodeNameUnsafe ::
+                  (MonadIO m, IsNode self, HasCallStack, FromJSString result) =>
+                    self -> m result
+getNodeNameUnsafe self
+  = liftIO
+      ((fromMaybeJSString <$> (js_getNodeName (toNode self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Node.nodeName Mozilla Node.nodeName documentation> 
 getNodeNameUnchecked ::
                      (MonadIO m, IsNode self, FromJSString result) => self -> m result
 getNodeNameUnchecked self
@@ -495,6 +605,15 @@
   = liftIO (fromMaybeJSString <$> (js_getNodeValue (toNode self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Node.nodeValue Mozilla Node.nodeValue documentation> 
+getNodeValueUnsafe ::
+                   (MonadIO m, IsNode self, HasCallStack, FromJSString result) =>
+                     self -> m result
+getNodeValueUnsafe self
+  = liftIO
+      ((fromMaybeJSString <$> (js_getNodeValue (toNode self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Node.nodeValue Mozilla Node.nodeValue documentation> 
 getNodeValueUnchecked ::
                       (MonadIO m, IsNode self, FromJSString result) => self -> m result
 getNodeValueUnchecked self
@@ -517,6 +636,14 @@
   = liftIO (nullableToMaybe <$> (js_getParentNode (toNode self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Node.parentNode Mozilla Node.parentNode documentation> 
+getParentNodeUnsafe ::
+                    (MonadIO m, IsNode self, HasCallStack) => self -> m Node
+getParentNodeUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getParentNode (toNode self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Node.parentNode Mozilla Node.parentNode documentation> 
 getParentNodeUnchecked ::
                        (MonadIO m, IsNode self) => self -> m Node
 getParentNodeUnchecked self
@@ -533,6 +660,14 @@
   = liftIO (nullableToMaybe <$> (js_getChildNodes (toNode self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Node.childNodes Mozilla Node.childNodes documentation> 
+getChildNodesUnsafe ::
+                    (MonadIO m, IsNode self, HasCallStack) => self -> m NodeList
+getChildNodesUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getChildNodes (toNode self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Node.childNodes Mozilla Node.childNodes documentation> 
 getChildNodesUnchecked ::
                        (MonadIO m, IsNode self) => self -> m NodeList
 getChildNodesUnchecked self
@@ -548,6 +683,14 @@
   = liftIO (nullableToMaybe <$> (js_getFirstChild (toNode self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Node.firstChild Mozilla Node.firstChild documentation> 
+getFirstChildUnsafe ::
+                    (MonadIO m, IsNode self, HasCallStack) => self -> m Node
+getFirstChildUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getFirstChild (toNode self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Node.firstChild Mozilla Node.firstChild documentation> 
 getFirstChildUnchecked ::
                        (MonadIO m, IsNode self) => self -> m Node
 getFirstChildUnchecked self
@@ -563,6 +706,14 @@
   = liftIO (nullableToMaybe <$> (js_getLastChild (toNode self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Node.lastChild Mozilla Node.lastChild documentation> 
+getLastChildUnsafe ::
+                   (MonadIO m, IsNode self, HasCallStack) => self -> m Node
+getLastChildUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getLastChild (toNode self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Node.lastChild Mozilla Node.lastChild documentation> 
 getLastChildUnchecked :: (MonadIO m, IsNode self) => self -> m Node
 getLastChildUnchecked self
   = liftIO
@@ -579,6 +730,14 @@
       (nullableToMaybe <$> (js_getPreviousSibling (toNode self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Node.previousSibling Mozilla Node.previousSibling documentation> 
+getPreviousSiblingUnsafe ::
+                         (MonadIO m, IsNode self, HasCallStack) => self -> m Node
+getPreviousSiblingUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getPreviousSibling (toNode self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Node.previousSibling Mozilla Node.previousSibling documentation> 
 getPreviousSiblingUnchecked ::
                             (MonadIO m, IsNode self) => self -> m Node
 getPreviousSiblingUnchecked self
@@ -596,6 +755,14 @@
   = liftIO (nullableToMaybe <$> (js_getNextSibling (toNode self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Node.nextSibling Mozilla Node.nextSibling documentation> 
+getNextSiblingUnsafe ::
+                     (MonadIO m, IsNode self, HasCallStack) => self -> m Node
+getNextSiblingUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getNextSibling (toNode self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Node.nextSibling Mozilla Node.nextSibling documentation> 
 getNextSiblingUnchecked ::
                         (MonadIO m, IsNode self) => self -> m Node
 getNextSiblingUnchecked self
@@ -612,6 +779,14 @@
   = liftIO (nullableToMaybe <$> (js_getOwnerDocument (toNode self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Node.ownerDocument Mozilla Node.ownerDocument documentation> 
+getOwnerDocumentUnsafe ::
+                       (MonadIO m, IsNode self, HasCallStack) => self -> m Document
+getOwnerDocumentUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getOwnerDocument (toNode self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Node.ownerDocument Mozilla Node.ownerDocument documentation> 
 getOwnerDocumentUnchecked ::
                           (MonadIO m, IsNode self) => self -> m Document
 getOwnerDocumentUnchecked self
@@ -630,6 +805,15 @@
   = liftIO (fromMaybeJSString <$> (js_getNamespaceURI (toNode self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Node.namespaceURI Mozilla Node.namespaceURI documentation> 
+getNamespaceURIUnsafe ::
+                      (MonadIO m, IsNode self, HasCallStack, FromJSString result) =>
+                        self -> m result
+getNamespaceURIUnsafe self
+  = liftIO
+      ((fromMaybeJSString <$> (js_getNamespaceURI (toNode self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Node.namespaceURI Mozilla Node.namespaceURI documentation> 
 getNamespaceURIUnchecked ::
                          (MonadIO m, IsNode self, FromJSString result) => self -> m result
 getNamespaceURIUnchecked self
@@ -658,6 +842,15 @@
   = liftIO (fromMaybeJSString <$> (js_getPrefix (toNode self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Node.prefix Mozilla Node.prefix documentation> 
+getPrefixUnsafe ::
+                (MonadIO m, IsNode self, HasCallStack, FromJSString result) =>
+                  self -> m result
+getPrefixUnsafe self
+  = liftIO
+      ((fromMaybeJSString <$> (js_getPrefix (toNode self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Node.prefix Mozilla Node.prefix documentation> 
 getPrefixUnchecked ::
                    (MonadIO m, IsNode self, FromJSString result) => self -> m result
 getPrefixUnchecked self
@@ -675,6 +868,15 @@
   = liftIO (fromMaybeJSString <$> (js_getLocalName (toNode self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Node.localName Mozilla Node.localName documentation> 
+getLocalNameUnsafe ::
+                   (MonadIO m, IsNode self, HasCallStack, FromJSString result) =>
+                     self -> m result
+getLocalNameUnsafe self
+  = liftIO
+      ((fromMaybeJSString <$> (js_getLocalName (toNode self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Node.localName Mozilla Node.localName documentation> 
 getLocalNameUnchecked ::
                       (MonadIO m, IsNode self, FromJSString result) => self -> m result
 getLocalNameUnchecked self
@@ -692,6 +894,15 @@
   = liftIO (fromMaybeJSString <$> (js_getBaseURI (toNode self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Node.baseURI Mozilla Node.baseURI documentation> 
+getBaseURIUnsafe ::
+                 (MonadIO m, IsNode self, HasCallStack, FromJSString result) =>
+                   self -> m result
+getBaseURIUnsafe self
+  = liftIO
+      ((fromMaybeJSString <$> (js_getBaseURI (toNode self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Node.baseURI Mozilla Node.baseURI documentation> 
 getBaseURIUnchecked ::
                     (MonadIO m, IsNode self, FromJSString result) => self -> m result
 getBaseURIUnchecked self
@@ -719,6 +930,15 @@
   = liftIO (fromMaybeJSString <$> (js_getTextContent (toNode self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Node.textContent Mozilla Node.textContent documentation> 
+getTextContentUnsafe ::
+                     (MonadIO m, IsNode self, HasCallStack, FromJSString result) =>
+                       self -> m result
+getTextContentUnsafe self
+  = liftIO
+      ((fromMaybeJSString <$> (js_getTextContent (toNode self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Node.textContent Mozilla Node.textContent documentation> 
 getTextContentUnchecked ::
                         (MonadIO m, IsNode self, FromJSString result) => self -> m result
 getTextContentUnchecked self
@@ -734,6 +954,14 @@
                  (MonadIO m, IsNode self) => self -> m (Maybe Element)
 getParentElement self
   = liftIO (nullableToMaybe <$> (js_getParentElement (toNode self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Node.parentElement Mozilla Node.parentElement documentation> 
+getParentElementUnsafe ::
+                       (MonadIO m, IsNode self, HasCallStack) => self -> m Element
+getParentElementUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getParentElement (toNode self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Node.parentElement Mozilla Node.parentElement documentation> 
 getParentElementUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/NodeFilter.hs b/src/GHCJS/DOM/JSFFI/Generated/NodeFilter.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/NodeFilter.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/NodeFilter.hs
@@ -1,4 +1,9 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.NodeFilter
        (js_acceptNode, acceptNode, acceptNode_, pattern FILTER_ACCEPT,
         pattern FILTER_REJECT, pattern FILTER_SKIP, pattern SHOW_ALL,
@@ -7,10 +12,10 @@
         pattern SHOW_ENTITY, pattern SHOW_PROCESSING_INSTRUCTION,
         pattern SHOW_COMMENT, pattern SHOW_DOCUMENT,
         pattern SHOW_DOCUMENT_TYPE, pattern SHOW_DOCUMENT_FRAGMENT,
-        pattern SHOW_NOTATION, NodeFilter, castToNodeFilter,
-        gTypeNodeFilter)
+        pattern SHOW_NOTATION, NodeFilter(..), gTypeNodeFilter)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -26,6 +31,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"acceptNode\"]($2)"
         js_acceptNode :: NodeFilter -> Nullable Node -> IO Int
diff --git a/src/GHCJS/DOM/JSFFI/Generated/NodeIterator.hs b/src/GHCJS/DOM/JSFFI/Generated/NodeIterator.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/NodeIterator.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/NodeIterator.hs
@@ -1,16 +1,23 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.NodeIterator
-       (js_nextNode, nextNode, nextNode_, nextNodeUnchecked,
-        js_previousNode, previousNode, previousNode_,
-        previousNodeUnchecked, js_detach, detach, js_getRoot, getRoot,
-        getRootUnchecked, js_getWhatToShow, getWhatToShow, js_getFilter,
-        getFilter, getFilterUnchecked, js_getExpandEntityReferences,
+       (js_nextNode, nextNode, nextNode_, nextNodeUnsafe,
+        nextNodeUnchecked, js_previousNode, previousNode, previousNode_,
+        previousNodeUnsafe, previousNodeUnchecked, js_detach, detach,
+        js_getRoot, getRoot, getRootUnsafe, getRootUnchecked,
+        js_getWhatToShow, getWhatToShow, js_getFilter, getFilter,
+        getFilterUnsafe, getFilterUnchecked, js_getExpandEntityReferences,
         getExpandEntityReferences, js_getReferenceNode, getReferenceNode,
-        getReferenceNodeUnchecked, js_getPointerBeforeReferenceNode,
-        getPointerBeforeReferenceNode, NodeIterator, castToNodeIterator,
-        gTypeNodeIterator)
+        getReferenceNodeUnsafe, getReferenceNodeUnchecked,
+        js_getPointerBeforeReferenceNode, getPointerBeforeReferenceNode,
+        NodeIterator(..), gTypeNodeIterator)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -26,6 +33,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"nextNode\"]()" js_nextNode
         :: NodeIterator -> IO (Nullable Node)
@@ -39,6 +56,14 @@
 nextNode_ self = liftIO (void (js_nextNode (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/NodeIterator.nextNode Mozilla NodeIterator.nextNode documentation> 
+nextNodeUnsafe ::
+               (MonadIO m, HasCallStack) => NodeIterator -> m Node
+nextNodeUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_nextNode (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/NodeIterator.nextNode Mozilla NodeIterator.nextNode documentation> 
 nextNodeUnchecked :: (MonadIO m) => NodeIterator -> m Node
 nextNodeUnchecked self
   = liftIO (fromJust . nullableToMaybe <$> (js_nextNode (self)))
@@ -56,6 +81,14 @@
 previousNode_ self = liftIO (void (js_previousNode (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/NodeIterator.previousNode Mozilla NodeIterator.previousNode documentation> 
+previousNodeUnsafe ::
+                   (MonadIO m, HasCallStack) => NodeIterator -> m Node
+previousNodeUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_previousNode (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/NodeIterator.previousNode Mozilla NodeIterator.previousNode documentation> 
 previousNodeUnchecked :: (MonadIO m) => NodeIterator -> m Node
 previousNodeUnchecked self
   = liftIO (fromJust . nullableToMaybe <$> (js_previousNode (self)))
@@ -75,6 +108,14 @@
 getRoot self = liftIO (nullableToMaybe <$> (js_getRoot (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/NodeIterator.root Mozilla NodeIterator.root documentation> 
+getRootUnsafe ::
+              (MonadIO m, HasCallStack) => NodeIterator -> m Node
+getRootUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getRoot (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/NodeIterator.root Mozilla NodeIterator.root documentation> 
 getRootUnchecked :: (MonadIO m) => NodeIterator -> m Node
 getRootUnchecked self
   = liftIO (fromJust . nullableToMaybe <$> (js_getRoot (self)))
@@ -94,6 +135,14 @@
 getFilter self = liftIO (nullableToMaybe <$> (js_getFilter (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/NodeIterator.filter Mozilla NodeIterator.filter documentation> 
+getFilterUnsafe ::
+                (MonadIO m, HasCallStack) => NodeIterator -> m NodeFilter
+getFilterUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getFilter (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/NodeIterator.filter Mozilla NodeIterator.filter documentation> 
 getFilterUnchecked :: (MonadIO m) => NodeIterator -> m NodeFilter
 getFilterUnchecked self
   = liftIO (fromJust . nullableToMaybe <$> (js_getFilter (self)))
@@ -114,6 +163,14 @@
 getReferenceNode :: (MonadIO m) => NodeIterator -> m (Maybe Node)
 getReferenceNode self
   = liftIO (nullableToMaybe <$> (js_getReferenceNode (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/NodeIterator.referenceNode Mozilla NodeIterator.referenceNode documentation> 
+getReferenceNodeUnsafe ::
+                       (MonadIO m, HasCallStack) => NodeIterator -> m Node
+getReferenceNodeUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getReferenceNode (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/NodeIterator.referenceNode Mozilla NodeIterator.referenceNode documentation> 
 getReferenceNodeUnchecked :: (MonadIO m) => NodeIterator -> m Node
diff --git a/src/GHCJS/DOM/JSFFI/Generated/NodeList.hs b/src/GHCJS/DOM/JSFFI/Generated/NodeList.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/NodeList.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/NodeList.hs
@@ -1,9 +1,15 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.NodeList
-       (js_item, item, item_, itemUnchecked, js_getLength, getLength,
-        NodeList, castToNodeList, gTypeNodeList, IsNodeList, toNodeList)
+       (js_item, item, item_, itemUnsafe, itemUnchecked, js_getLength,
+        getLength, NodeList(..), gTypeNodeList, IsNodeList, toNodeList)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -19,6 +25,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"item\"]($2)" js_item ::
         NodeList -> Word -> IO (Nullable Node)
@@ -32,6 +48,15 @@
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/NodeList.item Mozilla NodeList.item documentation> 
 item_ :: (MonadIO m, IsNodeList self) => self -> Word -> m ()
 item_ self index = liftIO (void (js_item (toNodeList self) index))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/NodeList.item Mozilla NodeList.item documentation> 
+itemUnsafe ::
+           (MonadIO m, IsNodeList self, HasCallStack) =>
+             self -> Word -> m Node
+itemUnsafe self index
+  = liftIO
+      ((nullableToMaybe <$> (js_item (toNodeList self) index)) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/NodeList.item Mozilla NodeList.item documentation> 
 itemUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/Notification.hs b/src/GHCJS/DOM/JSFFI/Generated/Notification.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/Notification.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/Notification.hs
@@ -1,9 +1,15 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.Notification
-       (js_show, show, showEvent, error, close, click, Notification,
-        castToNotification, gTypeNotification)
+       (js_show, show, showEvent, error, close, click, Notification(..),
+        gTypeNotification)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -19,6 +25,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"show\"]()" js_show ::
         Notification -> IO ()
diff --git a/src/GHCJS/DOM/JSFFI/Generated/NotificationCenter.hs b/src/GHCJS/DOM/JSFFI/Generated/NotificationCenter.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/NotificationCenter.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/NotificationCenter.hs
@@ -1,12 +1,18 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.NotificationCenter
        (js_createNotification, createNotification, createNotification_,
-        createNotificationUnchecked, js_checkPermission, checkPermission,
-        checkPermission_, js_requestPermission, requestPermission,
-        NotificationCenter, castToNotificationCenter,
+        createNotificationUnsafe, createNotificationUnchecked,
+        js_checkPermission, checkPermission, checkPermission_,
+        js_requestPermission, requestPermission, NotificationCenter(..),
         gTypeNotificationCenter)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -22,6 +28,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe
         "$1[\"createNotification\"]($2, $3,\n$4)" js_createNotification ::
@@ -52,6 +68,19 @@
          (js_createNotification (self) (toJSString iconUrl)
             (toJSString title)
             (toJSString body)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/NotificationCenter.createNotification Mozilla NotificationCenter.createNotification documentation> 
+createNotificationUnsafe ::
+                         (MonadIO m, ToJSString iconUrl, ToJSString title, ToJSString body,
+                          HasCallStack) =>
+                           NotificationCenter -> iconUrl -> title -> body -> m Notification
+createNotificationUnsafe self iconUrl title body
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_createNotification (self) (toJSString iconUrl)
+             (toJSString title)
+             (toJSString body)))
+         >>= maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/NotificationCenter.createNotification Mozilla NotificationCenter.createNotification documentation> 
 createNotificationUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/NotificationPermissionCallback.hs b/src/GHCJS/DOM/JSFFI/Generated/NotificationPermissionCallback.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/NotificationPermissionCallback.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/NotificationPermissionCallback.hs
@@ -1,4 +1,9 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.NotificationPermissionCallback
        (newNotificationPermissionCallback,
         newNotificationPermissionCallbackSync,
@@ -6,6 +11,7 @@
         NotificationPermissionCallback)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -21,6 +27,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/NotificationPermissionCallback Mozilla NotificationPermissionCallback documentation> 
 newNotificationPermissionCallback ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/OESStandardDerivatives.hs b/src/GHCJS/DOM/JSFFI/Generated/OESStandardDerivatives.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/OESStandardDerivatives.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/OESStandardDerivatives.hs
@@ -1,10 +1,15 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.OESStandardDerivatives
        (pattern FRAGMENT_SHADER_DERIVATIVE_HINT_OES,
-        OESStandardDerivatives, castToOESStandardDerivatives,
-        gTypeOESStandardDerivatives)
+        OESStandardDerivatives(..), gTypeOESStandardDerivatives)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -20,4 +25,14 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
 pattern FRAGMENT_SHADER_DERIVATIVE_HINT_OES = 35723
diff --git a/src/GHCJS/DOM/JSFFI/Generated/OESTextureHalfFloat.hs b/src/GHCJS/DOM/JSFFI/Generated/OESTextureHalfFloat.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/OESTextureHalfFloat.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/OESTextureHalfFloat.hs
@@ -1,9 +1,15 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.OESTextureHalfFloat
-       (pattern HALF_FLOAT_OES, OESTextureHalfFloat,
-        castToOESTextureHalfFloat, gTypeOESTextureHalfFloat)
+       (pattern HALF_FLOAT_OES, OESTextureHalfFloat(..),
+        gTypeOESTextureHalfFloat)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -19,4 +25,14 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
 pattern HALF_FLOAT_OES = 36193
diff --git a/src/GHCJS/DOM/JSFFI/Generated/OESVertexArrayObject.hs b/src/GHCJS/DOM/JSFFI/Generated/OESVertexArrayObject.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/OESVertexArrayObject.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/OESVertexArrayObject.hs
@@ -1,14 +1,20 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.OESVertexArrayObject
        (js_createVertexArrayOES, createVertexArrayOES,
-        createVertexArrayOES_, createVertexArrayOESUnchecked,
-        js_deleteVertexArrayOES, deleteVertexArrayOES, js_isVertexArrayOES,
-        isVertexArrayOES, isVertexArrayOES_, js_bindVertexArrayOES,
-        bindVertexArrayOES, pattern VERTEX_ARRAY_BINDING_OES,
-        OESVertexArrayObject, castToOESVertexArrayObject,
+        createVertexArrayOES_, createVertexArrayOESUnsafe,
+        createVertexArrayOESUnchecked, js_deleteVertexArrayOES,
+        deleteVertexArrayOES, js_isVertexArrayOES, isVertexArrayOES,
+        isVertexArrayOES_, js_bindVertexArrayOES, bindVertexArrayOES,
+        pattern VERTEX_ARRAY_BINDING_OES, OESVertexArrayObject(..),
         gTypeOESVertexArrayObject)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -24,6 +30,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"createVertexArrayOES\"]()"
         js_createVertexArrayOES ::
@@ -41,6 +57,15 @@
                       (MonadIO m) => OESVertexArrayObject -> m ()
 createVertexArrayOES_ self
   = liftIO (void (js_createVertexArrayOES (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/OESVertexArrayObject.createVertexArrayOES Mozilla OESVertexArrayObject.createVertexArrayOES documentation> 
+createVertexArrayOESUnsafe ::
+                           (MonadIO m, HasCallStack) =>
+                             OESVertexArrayObject -> m WebGLVertexArrayObjectOES
+createVertexArrayOESUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_createVertexArrayOES (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/OESVertexArrayObject.createVertexArrayOES Mozilla OESVertexArrayObject.createVertexArrayOES documentation> 
 createVertexArrayOESUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/OfflineAudioCompletionEvent.hs b/src/GHCJS/DOM/JSFFI/Generated/OfflineAudioCompletionEvent.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/OfflineAudioCompletionEvent.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/OfflineAudioCompletionEvent.hs
@@ -1,11 +1,16 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.OfflineAudioCompletionEvent
-       (js_getRenderedBuffer, getRenderedBuffer,
-        getRenderedBufferUnchecked, OfflineAudioCompletionEvent,
-        castToOfflineAudioCompletionEvent,
+       (js_getRenderedBuffer, getRenderedBuffer, getRenderedBufferUnsafe,
+        getRenderedBufferUnchecked, OfflineAudioCompletionEvent(..),
         gTypeOfflineAudioCompletionEvent)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -21,6 +26,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"renderedBuffer\"]"
         js_getRenderedBuffer ::
@@ -31,6 +46,15 @@
                   (MonadIO m) => OfflineAudioCompletionEvent -> m (Maybe AudioBuffer)
 getRenderedBuffer self
   = liftIO (nullableToMaybe <$> (js_getRenderedBuffer (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/OfflineAudioCompletionEvent.renderedBuffer Mozilla OfflineAudioCompletionEvent.renderedBuffer documentation> 
+getRenderedBufferUnsafe ::
+                        (MonadIO m, HasCallStack) =>
+                          OfflineAudioCompletionEvent -> m AudioBuffer
+getRenderedBufferUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getRenderedBuffer (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/OfflineAudioCompletionEvent.renderedBuffer Mozilla OfflineAudioCompletionEvent.renderedBuffer documentation> 
 getRenderedBufferUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/OfflineAudioContext.hs b/src/GHCJS/DOM/JSFFI/Generated/OfflineAudioContext.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/OfflineAudioContext.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/OfflineAudioContext.hs
@@ -1,10 +1,15 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.OfflineAudioContext
        (js_newOfflineAudioContext, newOfflineAudioContext,
-        OfflineAudioContext, castToOfflineAudioContext,
-        gTypeOfflineAudioContext)
+        OfflineAudioContext(..), gTypeOfflineAudioContext)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -20,6 +25,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe
         "new window[\"OfflineAudioContext\"]($1,\n$2, $3)"
diff --git a/src/GHCJS/DOM/JSFFI/Generated/OscillatorNode.hs b/src/GHCJS/DOM/JSFFI/Generated/OscillatorNode.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/OscillatorNode.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/OscillatorNode.hs
@@ -1,4 +1,9 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.OscillatorNode
        (js_start, start, js_stop, stop, js_noteOn, noteOn, js_noteOff,
         noteOff, js_setPeriodicWave, setPeriodicWave, pattern SINE,
@@ -6,11 +11,12 @@
         pattern UNSCHEDULED_STATE, pattern SCHEDULED_STATE,
         pattern PLAYING_STATE, pattern FINISHED_STATE, js_setType, setType,
         js_getType, getType, js_getPlaybackState, getPlaybackState,
-        js_getFrequency, getFrequency, getFrequencyUnchecked, js_getDetune,
-        getDetune, getDetuneUnchecked, ended, OscillatorNode,
-        castToOscillatorNode, gTypeOscillatorNode)
+        js_getFrequency, getFrequency, getFrequencyUnsafe,
+        getFrequencyUnchecked, js_getDetune, getDetune, getDetuneUnsafe,
+        getDetuneUnchecked, ended, OscillatorNode(..), gTypeOscillatorNode)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -26,6 +32,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"start\"]($2)" js_start ::
         OscillatorNode -> Double -> IO ()
@@ -107,6 +123,14 @@
   = liftIO (nullableToMaybe <$> (js_getFrequency (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/OscillatorNode.frequency Mozilla OscillatorNode.frequency documentation> 
+getFrequencyUnsafe ::
+                   (MonadIO m, HasCallStack) => OscillatorNode -> m AudioParam
+getFrequencyUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getFrequency (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/OscillatorNode.frequency Mozilla OscillatorNode.frequency documentation> 
 getFrequencyUnchecked ::
                       (MonadIO m) => OscillatorNode -> m AudioParam
 getFrequencyUnchecked self
@@ -118,6 +142,14 @@
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/OscillatorNode.detune Mozilla OscillatorNode.detune documentation> 
 getDetune :: (MonadIO m) => OscillatorNode -> m (Maybe AudioParam)
 getDetune self = liftIO (nullableToMaybe <$> (js_getDetune (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/OscillatorNode.detune Mozilla OscillatorNode.detune documentation> 
+getDetuneUnsafe ::
+                (MonadIO m, HasCallStack) => OscillatorNode -> m AudioParam
+getDetuneUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getDetune (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/OscillatorNode.detune Mozilla OscillatorNode.detune documentation> 
 getDetuneUnchecked :: (MonadIO m) => OscillatorNode -> m AudioParam
diff --git a/src/GHCJS/DOM/JSFFI/Generated/OverflowEvent.hs b/src/GHCJS/DOM/JSFFI/Generated/OverflowEvent.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/OverflowEvent.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/OverflowEvent.hs
@@ -1,11 +1,17 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.OverflowEvent
        (pattern HORIZONTAL, pattern VERTICAL, pattern BOTH, js_getOrient,
         getOrient, js_getHorizontalOverflow, getHorizontalOverflow,
-        js_getVerticalOverflow, getVerticalOverflow, OverflowEvent,
-        castToOverflowEvent, gTypeOverflowEvent)
+        js_getVerticalOverflow, getVerticalOverflow, OverflowEvent(..),
+        gTypeOverflowEvent)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -21,6 +27,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
 pattern HORIZONTAL = 0
 pattern VERTICAL = 1
 pattern BOTH = 2
diff --git a/src/GHCJS/DOM/JSFFI/Generated/PageTransitionEvent.hs b/src/GHCJS/DOM/JSFFI/Generated/PageTransitionEvent.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/PageTransitionEvent.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/PageTransitionEvent.hs
@@ -1,9 +1,15 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.PageTransitionEvent
-       (js_getPersisted, getPersisted, PageTransitionEvent,
-        castToPageTransitionEvent, gTypePageTransitionEvent)
+       (js_getPersisted, getPersisted, PageTransitionEvent(..),
+        gTypePageTransitionEvent)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -19,6 +25,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "($1[\"persisted\"] ? 1 : 0)"
         js_getPersisted :: PageTransitionEvent -> IO Bool
diff --git a/src/GHCJS/DOM/JSFFI/Generated/PannerNode.hs b/src/GHCJS/DOM/JSFFI/Generated/PannerNode.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/PannerNode.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/PannerNode.hs
@@ -1,4 +1,9 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.PannerNode
        (js_setPosition, setPosition, js_setOrientation, setOrientation,
         js_setVelocity, setVelocity, pattern EQUALPOWER, pattern HRTF,
@@ -14,10 +19,11 @@
         setConeInnerAngle, js_getConeInnerAngle, getConeInnerAngle,
         js_setConeOuterAngle, setConeOuterAngle, js_getConeOuterAngle,
         getConeOuterAngle, js_setConeOuterGain, setConeOuterGain,
-        js_getConeOuterGain, getConeOuterGain, PannerNode,
-        castToPannerNode, gTypePannerNode)
+        js_getConeOuterGain, getConeOuterGain, PannerNode(..),
+        gTypePannerNode)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -33,6 +39,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"setPosition\"]($2, $3, $4)"
         js_setPosition :: PannerNode -> Float -> Float -> Float -> IO ()
diff --git a/src/GHCJS/DOM/JSFFI/Generated/Path2D.hs b/src/GHCJS/DOM/JSFFI/Generated/Path2D.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/Path2D.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/Path2D.hs
@@ -1,13 +1,19 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.Path2D
        (js_newPath2D, newPath2D, js_newPath2D', newPath2D',
         js_newPath2D'', newPath2D'', js_addPath, addPath, js_closePath,
         closePath, js_moveTo, moveTo, js_lineTo, lineTo,
         js_quadraticCurveTo, quadraticCurveTo, js_bezierCurveTo,
-        bezierCurveTo, js_arcTo, arcTo, js_rect, rect, js_arc, arc, Path2D,
-        castToPath2D, gTypePath2D)
+        bezierCurveTo, js_arcTo, arcTo, js_rect, rect, js_arc, arc,
+        Path2D(..), gTypePath2D)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -23,6 +29,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "new window[\"Path2D\"]()"
         js_newPath2D :: IO Path2D
diff --git a/src/GHCJS/DOM/JSFFI/Generated/Performance.hs b/src/GHCJS/DOM/JSFFI/Generated/Performance.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/Performance.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/Performance.hs
@@ -1,21 +1,29 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.Performance
        (js_webkitGetEntries, webkitGetEntries, webkitGetEntries_,
-        webkitGetEntriesUnchecked, js_webkitGetEntriesByType,
-        webkitGetEntriesByType, webkitGetEntriesByType_,
+        webkitGetEntriesUnsafe, webkitGetEntriesUnchecked,
+        js_webkitGetEntriesByType, webkitGetEntriesByType,
+        webkitGetEntriesByType_, webkitGetEntriesByTypeUnsafe,
         webkitGetEntriesByTypeUnchecked, js_webkitGetEntriesByName,
         webkitGetEntriesByName, webkitGetEntriesByName_,
-        webkitGetEntriesByNameUnchecked, js_webkitClearResourceTimings,
-        webkitClearResourceTimings, js_webkitSetResourceTimingBufferSize,
+        webkitGetEntriesByNameUnsafe, webkitGetEntriesByNameUnchecked,
+        js_webkitClearResourceTimings, webkitClearResourceTimings,
+        js_webkitSetResourceTimingBufferSize,
         webkitSetResourceTimingBufferSize, js_webkitMark, webkitMark,
         js_webkitClearMarks, webkitClearMarks, js_webkitMeasure,
         webkitMeasure, js_webkitClearMeasures, webkitClearMeasures, js_now,
-        now, now_, js_getNavigation, getNavigation, getNavigationUnchecked,
-        js_getTiming, getTiming, getTimingUnchecked,
-        webKitResourceTimingBufferFull, Performance, castToPerformance,
-        gTypePerformance)
+        now, now_, js_getNavigation, getNavigation, getNavigationUnsafe,
+        getNavigationUnchecked, js_getTiming, getTiming, getTimingUnsafe,
+        getTimingUnchecked, webKitResourceTimingBufferFull,
+        Performance(..), gTypePerformance)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -31,6 +39,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"webkitGetEntries\"]()"
         js_webkitGetEntries ::
@@ -47,6 +65,14 @@
 webkitGetEntries_ self = liftIO (void (js_webkitGetEntries (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Performance.webkitGetEntries Mozilla Performance.webkitGetEntries documentation> 
+webkitGetEntriesUnsafe ::
+                       (MonadIO m, HasCallStack) => Performance -> m PerformanceEntryList
+webkitGetEntriesUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_webkitGetEntries (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Performance.webkitGetEntries Mozilla Performance.webkitGetEntries documentation> 
 webkitGetEntriesUnchecked ::
                           (MonadIO m) => Performance -> m PerformanceEntryList
 webkitGetEntriesUnchecked self
@@ -75,6 +101,16 @@
       (void (js_webkitGetEntriesByType (self) (toJSString entryType)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Performance.webkitGetEntriesByType Mozilla Performance.webkitGetEntriesByType documentation> 
+webkitGetEntriesByTypeUnsafe ::
+                             (MonadIO m, ToJSString entryType, HasCallStack) =>
+                               Performance -> entryType -> m PerformanceEntryList
+webkitGetEntriesByTypeUnsafe self entryType
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_webkitGetEntriesByType (self) (toJSString entryType)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Performance.webkitGetEntriesByType Mozilla Performance.webkitGetEntriesByType documentation> 
 webkitGetEntriesByTypeUnchecked ::
                                 (MonadIO m, ToJSString entryType) =>
                                   Performance -> entryType -> m PerformanceEntryList
@@ -110,6 +146,17 @@
             (toJSString entryType)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Performance.webkitGetEntriesByName Mozilla Performance.webkitGetEntriesByName documentation> 
+webkitGetEntriesByNameUnsafe ::
+                             (MonadIO m, ToJSString name, ToJSString entryType, HasCallStack) =>
+                               Performance -> name -> entryType -> m PerformanceEntryList
+webkitGetEntriesByNameUnsafe self name entryType
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_webkitGetEntriesByName (self) (toJSString name)
+             (toJSString entryType)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Performance.webkitGetEntriesByName Mozilla Performance.webkitGetEntriesByName documentation> 
 webkitGetEntriesByNameUnchecked ::
                                 (MonadIO m, ToJSString name, ToJSString entryType) =>
                                   Performance -> name -> entryType -> m PerformanceEntryList
@@ -204,6 +251,14 @@
   = liftIO (nullableToMaybe <$> (js_getNavigation (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Performance.navigation Mozilla Performance.navigation documentation> 
+getNavigationUnsafe ::
+                    (MonadIO m, HasCallStack) => Performance -> m PerformanceNavigation
+getNavigationUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getNavigation (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Performance.navigation Mozilla Performance.navigation documentation> 
 getNavigationUnchecked ::
                        (MonadIO m) => Performance -> m PerformanceNavigation
 getNavigationUnchecked self
@@ -216,6 +271,14 @@
 getTiming ::
           (MonadIO m) => Performance -> m (Maybe PerformanceTiming)
 getTiming self = liftIO (nullableToMaybe <$> (js_getTiming (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Performance.timing Mozilla Performance.timing documentation> 
+getTimingUnsafe ::
+                (MonadIO m, HasCallStack) => Performance -> m PerformanceTiming
+getTimingUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getTiming (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Performance.timing Mozilla Performance.timing documentation> 
 getTimingUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/PerformanceEntry.hs b/src/GHCJS/DOM/JSFFI/Generated/PerformanceEntry.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/PerformanceEntry.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/PerformanceEntry.hs
@@ -1,11 +1,17 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.PerformanceEntry
        (js_getName, getName, js_getEntryType, getEntryType,
         js_getStartTime, getStartTime, js_getDuration, getDuration,
-        PerformanceEntry, castToPerformanceEntry, gTypePerformanceEntry,
-        IsPerformanceEntry, toPerformanceEntry)
+        PerformanceEntry(..), gTypePerformanceEntry, IsPerformanceEntry,
+        toPerformanceEntry)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -21,6 +27,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"name\"]" js_getName ::
         PerformanceEntry -> IO JSString
diff --git a/src/GHCJS/DOM/JSFFI/Generated/PerformanceEntryList.hs b/src/GHCJS/DOM/JSFFI/Generated/PerformanceEntryList.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/PerformanceEntryList.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/PerformanceEntryList.hs
@@ -1,10 +1,15 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.PerformanceEntryList
-       (js_item, item, item_, itemUnchecked, js_getLength, getLength,
-        PerformanceEntryList, castToPerformanceEntryList,
-        gTypePerformanceEntryList)
+       (js_item, item, item_, itemUnsafe, itemUnchecked, js_getLength,
+        getLength, PerformanceEntryList(..), gTypePerformanceEntryList)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -20,6 +25,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"item\"]($2)" js_item ::
         PerformanceEntryList -> Word -> IO (Nullable PerformanceEntry)
@@ -34,6 +49,15 @@
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/PerformanceEntryList.item Mozilla PerformanceEntryList.item documentation> 
 item_ :: (MonadIO m) => PerformanceEntryList -> Word -> m ()
 item_ self index = liftIO (void (js_item (self) index))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/PerformanceEntryList.item Mozilla PerformanceEntryList.item documentation> 
+itemUnsafe ::
+           (MonadIO m, HasCallStack) =>
+             PerformanceEntryList -> Word -> m PerformanceEntry
+itemUnsafe self index
+  = liftIO
+      ((nullableToMaybe <$> (js_item (self) index)) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/PerformanceEntryList.item Mozilla PerformanceEntryList.item documentation> 
 itemUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/PerformanceNavigation.hs b/src/GHCJS/DOM/JSFFI/Generated/PerformanceNavigation.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/PerformanceNavigation.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/PerformanceNavigation.hs
@@ -1,12 +1,17 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.PerformanceNavigation
        (pattern TYPE_NAVIGATE, pattern TYPE_RELOAD,
         pattern TYPE_BACK_FORWARD, pattern TYPE_RESERVED, js_getType,
         getType, js_getRedirectCount, getRedirectCount,
-        PerformanceNavigation, castToPerformanceNavigation,
-        gTypePerformanceNavigation)
+        PerformanceNavigation(..), gTypePerformanceNavigation)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -22,6 +27,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
 pattern TYPE_NAVIGATE = 0
 pattern TYPE_RELOAD = 1
 pattern TYPE_BACK_FORWARD = 2
diff --git a/src/GHCJS/DOM/JSFFI/Generated/PerformanceResourceTiming.hs b/src/GHCJS/DOM/JSFFI/Generated/PerformanceResourceTiming.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/PerformanceResourceTiming.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/PerformanceResourceTiming.hs
@@ -1,4 +1,9 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.PerformanceResourceTiming
        (js_getInitiatorType, getInitiatorType, js_getRedirectStart,
         getRedirectStart, js_getRedirectEnd, getRedirectEnd,
@@ -7,10 +12,11 @@
         js_getConnectStart, getConnectStart, js_getConnectEnd,
         getConnectEnd, js_getSecureConnectionStart,
         getSecureConnectionStart, js_getRequestStart, getRequestStart,
-        js_getResponseEnd, getResponseEnd, PerformanceResourceTiming,
-        castToPerformanceResourceTiming, gTypePerformanceResourceTiming)
+        js_getResponseEnd, getResponseEnd, PerformanceResourceTiming(..),
+        gTypePerformanceResourceTiming)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -26,6 +32,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"initiatorType\"]"
         js_getInitiatorType :: PerformanceResourceTiming -> IO JSString
diff --git a/src/GHCJS/DOM/JSFFI/Generated/PerformanceTiming.hs b/src/GHCJS/DOM/JSFFI/Generated/PerformanceTiming.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/PerformanceTiming.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/PerformanceTiming.hs
@@ -1,4 +1,9 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.PerformanceTiming
        (js_getNavigationStart, getNavigationStart, js_getUnloadEventStart,
         getUnloadEventStart, js_getUnloadEventEnd, getUnloadEventEnd,
@@ -15,10 +20,10 @@
         getDomContentLoadedEventStart, js_getDomContentLoadedEventEnd,
         getDomContentLoadedEventEnd, js_getDomComplete, getDomComplete,
         js_getLoadEventStart, getLoadEventStart, js_getLoadEventEnd,
-        getLoadEventEnd, PerformanceTiming, castToPerformanceTiming,
-        gTypePerformanceTiming)
+        getLoadEventEnd, PerformanceTiming(..), gTypePerformanceTiming)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -34,6 +39,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"navigationStart\"]"
         js_getNavigationStart :: PerformanceTiming -> IO Double
diff --git a/src/GHCJS/DOM/JSFFI/Generated/Plugin.hs b/src/GHCJS/DOM/JSFFI/Generated/Plugin.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/Plugin.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/Plugin.hs
@@ -1,11 +1,18 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.Plugin
-       (js_item, item, item_, itemUnchecked, js_namedItem, namedItem,
-        namedItem_, namedItemUnchecked, js_getName, getName,
-        js_getFilename, getFilename, js_getDescription, getDescription,
-        js_getLength, getLength, Plugin, castToPlugin, gTypePlugin)
+       (js_item, item, item_, itemUnsafe, itemUnchecked, js_namedItem,
+        namedItem, namedItem_, namedItemUnsafe, namedItemUnchecked,
+        js_getName, getName, js_getFilename, getFilename,
+        js_getDescription, getDescription, js_getLength, getLength,
+        Plugin(..), gTypePlugin)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -21,6 +28,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"item\"]($2)" js_item ::
         Plugin -> Word -> IO (Nullable MimeType)
@@ -35,6 +52,14 @@
 item_ self index = liftIO (void (js_item (self) index))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Plugin.item Mozilla Plugin.item documentation> 
+itemUnsafe ::
+           (MonadIO m, HasCallStack) => Plugin -> Word -> m MimeType
+itemUnsafe self index
+  = liftIO
+      ((nullableToMaybe <$> (js_item (self) index)) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Plugin.item Mozilla Plugin.item documentation> 
 itemUnchecked :: (MonadIO m) => Plugin -> Word -> m MimeType
 itemUnchecked self index
   = liftIO (fromJust . nullableToMaybe <$> (js_item (self) index))
@@ -55,6 +80,15 @@
            (MonadIO m, ToJSString name) => Plugin -> name -> m ()
 namedItem_ self name
   = liftIO (void (js_namedItem (self) (toJSString name)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Plugin.namedItem Mozilla Plugin.namedItem documentation> 
+namedItemUnsafe ::
+                (MonadIO m, ToJSString name, HasCallStack) =>
+                  Plugin -> name -> m MimeType
+namedItemUnsafe self name
+  = liftIO
+      ((nullableToMaybe <$> (js_namedItem (self) (toJSString name))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Plugin.namedItem Mozilla Plugin.namedItem documentation> 
 namedItemUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/PluginArray.hs b/src/GHCJS/DOM/JSFFI/Generated/PluginArray.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/PluginArray.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/PluginArray.hs
@@ -1,10 +1,17 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.PluginArray
-       (js_item, item, item_, itemUnchecked, js_namedItem, namedItem,
-        namedItem_, namedItemUnchecked, js_refresh, refresh, js_getLength,
-        getLength, PluginArray, castToPluginArray, gTypePluginArray)
+       (js_item, item, item_, itemUnsafe, itemUnchecked, js_namedItem,
+        namedItem, namedItem_, namedItemUnsafe, namedItemUnchecked,
+        js_refresh, refresh, js_getLength, getLength, PluginArray(..),
+        gTypePluginArray)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -20,6 +27,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"item\"]($2)" js_item ::
         PluginArray -> Word -> IO (Nullable Plugin)
@@ -34,6 +51,14 @@
 item_ self index = liftIO (void (js_item (self) index))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/PluginArray.item Mozilla PluginArray.item documentation> 
+itemUnsafe ::
+           (MonadIO m, HasCallStack) => PluginArray -> Word -> m Plugin
+itemUnsafe self index
+  = liftIO
+      ((nullableToMaybe <$> (js_item (self) index)) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/PluginArray.item Mozilla PluginArray.item documentation> 
 itemUnchecked :: (MonadIO m) => PluginArray -> Word -> m Plugin
 itemUnchecked self index
   = liftIO (fromJust . nullableToMaybe <$> (js_item (self) index))
@@ -54,6 +79,15 @@
            (MonadIO m, ToJSString name) => PluginArray -> name -> m ()
 namedItem_ self name
   = liftIO (void (js_namedItem (self) (toJSString name)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/PluginArray.namedItem Mozilla PluginArray.namedItem documentation> 
+namedItemUnsafe ::
+                (MonadIO m, ToJSString name, HasCallStack) =>
+                  PluginArray -> name -> m Plugin
+namedItemUnsafe self name
+  = liftIO
+      ((nullableToMaybe <$> (js_namedItem (self) (toJSString name))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/PluginArray.namedItem Mozilla PluginArray.namedItem documentation> 
 namedItemUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/PopStateEvent.hs b/src/GHCJS/DOM/JSFFI/Generated/PopStateEvent.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/PopStateEvent.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/PopStateEvent.hs
@@ -1,9 +1,14 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.PopStateEvent
-       (js_getState, getState, PopStateEvent, castToPopStateEvent,
-        gTypePopStateEvent)
+       (js_getState, getState, PopStateEvent(..), gTypePopStateEvent)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -19,6 +24,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"state\"]" js_getState ::
         PopStateEvent -> IO JSVal
diff --git a/src/GHCJS/DOM/JSFFI/Generated/PositionCallback.hs b/src/GHCJS/DOM/JSFFI/Generated/PositionCallback.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/PositionCallback.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/PositionCallback.hs
@@ -1,9 +1,15 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.PositionCallback
        (newPositionCallback, newPositionCallbackSync,
         newPositionCallbackAsync, PositionCallback)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -19,6 +25,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/PositionCallback Mozilla PositionCallback documentation> 
 newPositionCallback ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/PositionError.hs b/src/GHCJS/DOM/JSFFI/Generated/PositionError.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/PositionError.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/PositionError.hs
@@ -1,10 +1,16 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.PositionError
        (pattern PERMISSION_DENIED, pattern POSITION_UNAVAILABLE,
         pattern TIMEOUT, js_getCode, getCode, js_getMessage, getMessage,
-        PositionError, castToPositionError, gTypePositionError)
+        PositionError(..), gTypePositionError)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -20,6 +26,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
 pattern PERMISSION_DENIED = 1
 pattern POSITION_UNAVAILABLE = 2
 pattern TIMEOUT = 3
diff --git a/src/GHCJS/DOM/JSFFI/Generated/PositionErrorCallback.hs b/src/GHCJS/DOM/JSFFI/Generated/PositionErrorCallback.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/PositionErrorCallback.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/PositionErrorCallback.hs
@@ -1,9 +1,15 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.PositionErrorCallback
        (newPositionErrorCallback, newPositionErrorCallbackSync,
         newPositionErrorCallbackAsync, PositionErrorCallback)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -19,6 +25,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/PositionErrorCallback Mozilla PositionErrorCallback documentation> 
 newPositionErrorCallback ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/ProcessingInstruction.hs b/src/GHCJS/DOM/JSFFI/Generated/ProcessingInstruction.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/ProcessingInstruction.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/ProcessingInstruction.hs
@@ -1,10 +1,16 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.ProcessingInstruction
-       (js_getTarget, getTarget, getTargetUnchecked, js_getSheet,
-        getSheet, getSheetUnchecked, ProcessingInstruction,
-        castToProcessingInstruction, gTypeProcessingInstruction)
+       (js_getTarget, getTarget, getTargetUnsafe, getTargetUnchecked,
+        js_getSheet, getSheet, getSheetUnsafe, getSheetUnchecked,
+        ProcessingInstruction(..), gTypeProcessingInstruction)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -20,6 +26,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"target\"]" js_getTarget ::
         ProcessingInstruction -> IO (Nullable JSString)
@@ -32,6 +48,15 @@
   = liftIO (fromMaybeJSString <$> (js_getTarget (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/ProcessingInstruction.target Mozilla ProcessingInstruction.target documentation> 
+getTargetUnsafe ::
+                (MonadIO m, HasCallStack, FromJSString result) =>
+                  ProcessingInstruction -> m result
+getTargetUnsafe self
+  = liftIO
+      ((fromMaybeJSString <$> (js_getTarget (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/ProcessingInstruction.target Mozilla ProcessingInstruction.target documentation> 
 getTargetUnchecked ::
                    (MonadIO m, FromJSString result) =>
                      ProcessingInstruction -> m result
@@ -45,6 +70,14 @@
 getSheet ::
          (MonadIO m) => ProcessingInstruction -> m (Maybe StyleSheet)
 getSheet self = liftIO (nullableToMaybe <$> (js_getSheet (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/ProcessingInstruction.sheet Mozilla ProcessingInstruction.sheet documentation> 
+getSheetUnsafe ::
+               (MonadIO m, HasCallStack) => ProcessingInstruction -> m StyleSheet
+getSheetUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getSheet (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/ProcessingInstruction.sheet Mozilla ProcessingInstruction.sheet documentation> 
 getSheetUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/ProgressEvent.hs b/src/GHCJS/DOM/JSFFI/Generated/ProgressEvent.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/ProgressEvent.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/ProgressEvent.hs
@@ -1,11 +1,16 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.ProgressEvent
        (js_getLengthComputable, getLengthComputable, js_getLoaded,
-        getLoaded, js_getTotal, getTotal, ProgressEvent,
-        castToProgressEvent, gTypeProgressEvent, IsProgressEvent,
-        toProgressEvent)
+        getLoaded, js_getTotal, getTotal, ProgressEvent(..),
+        gTypeProgressEvent, IsProgressEvent, toProgressEvent)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -21,6 +26,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe
         "($1[\"lengthComputable\"] ? 1 : 0)" js_getLengthComputable ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/QuickTimePluginReplacement.hs b/src/GHCJS/DOM/JSFFI/Generated/QuickTimePluginReplacement.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/QuickTimePluginReplacement.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/QuickTimePluginReplacement.hs
@@ -1,12 +1,17 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.QuickTimePluginReplacement
        (js_postEvent, postEvent, js_getMovieSize, getMovieSize,
         js_getTimedMetaData, getTimedMetaData, js_getAccessLog,
         getAccessLog, js_getErrorLog, getErrorLog,
-        QuickTimePluginReplacement, castToQuickTimePluginReplacement,
-        gTypeQuickTimePluginReplacement)
+        QuickTimePluginReplacement(..), gTypeQuickTimePluginReplacement)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -22,6 +27,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"postEvent\"]($2)"
         js_postEvent :: QuickTimePluginReplacement -> JSString -> IO ()
diff --git a/src/GHCJS/DOM/JSFFI/Generated/RGBColor.hs b/src/GHCJS/DOM/JSFFI/Generated/RGBColor.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/RGBColor.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/RGBColor.hs
@@ -1,10 +1,16 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.RGBColor
-       (js_getRed, getRed, getRedUnchecked, js_getGreen, getGreen,
-        getGreenUnchecked, js_getBlue, getBlue, getBlueUnchecked, RGBColor,
-        castToRGBColor, gTypeRGBColor)
+       (js_getRed, getRed, getRedUnsafe, getRedUnchecked, js_getGreen,
+        getGreen, getGreenUnsafe, getGreenUnchecked, js_getBlue, getBlue,
+        getBlueUnsafe, getBlueUnchecked, RGBColor(..), gTypeRGBColor)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -20,6 +26,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"red\"]" js_getRed ::
         RGBColor -> IO (Nullable CSSPrimitiveValue)
@@ -29,6 +45,14 @@
 getRed self = liftIO (nullableToMaybe <$> (js_getRed (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/RGBColor.red Mozilla RGBColor.red documentation> 
+getRedUnsafe ::
+             (MonadIO m, HasCallStack) => RGBColor -> m CSSPrimitiveValue
+getRedUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getRed (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/RGBColor.red Mozilla RGBColor.red documentation> 
 getRedUnchecked :: (MonadIO m) => RGBColor -> m CSSPrimitiveValue
 getRedUnchecked self
   = liftIO (fromJust . nullableToMaybe <$> (js_getRed (self)))
@@ -41,6 +65,14 @@
 getGreen self = liftIO (nullableToMaybe <$> (js_getGreen (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/RGBColor.green Mozilla RGBColor.green documentation> 
+getGreenUnsafe ::
+               (MonadIO m, HasCallStack) => RGBColor -> m CSSPrimitiveValue
+getGreenUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getGreen (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/RGBColor.green Mozilla RGBColor.green documentation> 
 getGreenUnchecked :: (MonadIO m) => RGBColor -> m CSSPrimitiveValue
 getGreenUnchecked self
   = liftIO (fromJust . nullableToMaybe <$> (js_getGreen (self)))
@@ -51,6 +83,14 @@
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/RGBColor.blue Mozilla RGBColor.blue documentation> 
 getBlue :: (MonadIO m) => RGBColor -> m (Maybe CSSPrimitiveValue)
 getBlue self = liftIO (nullableToMaybe <$> (js_getBlue (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/RGBColor.blue Mozilla RGBColor.blue documentation> 
+getBlueUnsafe ::
+              (MonadIO m, HasCallStack) => RGBColor -> m CSSPrimitiveValue
+getBlueUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getBlue (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/RGBColor.blue Mozilla RGBColor.blue documentation> 
 getBlueUnchecked :: (MonadIO m) => RGBColor -> m CSSPrimitiveValue
diff --git a/src/GHCJS/DOM/JSFFI/Generated/RTCConfiguration.hs b/src/GHCJS/DOM/JSFFI/Generated/RTCConfiguration.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/RTCConfiguration.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/RTCConfiguration.hs
@@ -1,10 +1,16 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.RTCConfiguration
        (js_getIceServers, getIceServers, js_getIceTransports,
         getIceTransports, js_getRequestIdentity, getRequestIdentity,
-        RTCConfiguration, castToRTCConfiguration, gTypeRTCConfiguration)
+        RTCConfiguration(..), gTypeRTCConfiguration)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -20,6 +26,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"iceServers\"]"
         js_getIceServers :: RTCConfiguration -> IO JSVal
diff --git a/src/GHCJS/DOM/JSFFI/Generated/RTCDTMFSender.hs b/src/GHCJS/DOM/JSFFI/Generated/RTCDTMFSender.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/RTCDTMFSender.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/RTCDTMFSender.hs
@@ -1,12 +1,18 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.RTCDTMFSender
        (js_insertDTMF, insertDTMF, js_getCanInsertDTMF, getCanInsertDTMF,
-        js_getTrack, getTrack, getTrackUnchecked, js_getToneBuffer,
-        getToneBuffer, js_getDuration, getDuration, js_getInterToneGap,
-        getInterToneGap, toneChange, RTCDTMFSender, castToRTCDTMFSender,
+        js_getTrack, getTrack, getTrackUnsafe, getTrackUnchecked,
+        js_getToneBuffer, getToneBuffer, js_getDuration, getDuration,
+        js_getInterToneGap, getInterToneGap, toneChange, RTCDTMFSender(..),
         gTypeRTCDTMFSender)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -22,6 +28,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"insertDTMF\"]($2, $3, $4)"
         js_insertDTMF :: RTCDTMFSender -> JSString -> Int -> Int -> IO ()
@@ -48,6 +64,14 @@
 getTrack ::
          (MonadIO m) => RTCDTMFSender -> m (Maybe MediaStreamTrack)
 getTrack self = liftIO (nullableToMaybe <$> (js_getTrack (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/RTCDTMFSender.track Mozilla RTCDTMFSender.track documentation> 
+getTrackUnsafe ::
+               (MonadIO m, HasCallStack) => RTCDTMFSender -> m MediaStreamTrack
+getTrackUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getTrack (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/RTCDTMFSender.track Mozilla RTCDTMFSender.track documentation> 
 getTrackUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/RTCDTMFToneChangeEvent.hs b/src/GHCJS/DOM/JSFFI/Generated/RTCDTMFToneChangeEvent.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/RTCDTMFToneChangeEvent.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/RTCDTMFToneChangeEvent.hs
@@ -1,9 +1,15 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.RTCDTMFToneChangeEvent
-       (js_getTone, getTone, RTCDTMFToneChangeEvent,
-        castToRTCDTMFToneChangeEvent, gTypeRTCDTMFToneChangeEvent)
+       (js_getTone, getTone, RTCDTMFToneChangeEvent(..),
+        gTypeRTCDTMFToneChangeEvent)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -19,6 +25,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"tone\"]" js_getTone ::
         RTCDTMFToneChangeEvent -> IO JSString
diff --git a/src/GHCJS/DOM/JSFFI/Generated/RTCDataChannel.hs b/src/GHCJS/DOM/JSFFI/Generated/RTCDataChannel.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/RTCDataChannel.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/RTCDataChannel.hs
@@ -1,4 +1,9 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.RTCDataChannel
        (js_send, send, js_sendView, sendView, js_sendBlob, sendBlob,
         js_sendString, sendString, js_close, close, js_getLabel, getLabel,
@@ -8,10 +13,10 @@
         js_getId, getId, js_getReadyState, getReadyState,
         js_getBufferedAmount, getBufferedAmount, js_setBinaryType,
         setBinaryType, js_getBinaryType, getBinaryType, open, error,
-        closeEvent, message, RTCDataChannel, castToRTCDataChannel,
-        gTypeRTCDataChannel)
+        closeEvent, message, RTCDataChannel(..), gTypeRTCDataChannel)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -27,6 +32,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"send\"]($2)" js_send ::
         RTCDataChannel -> Nullable ArrayBuffer -> IO ()
diff --git a/src/GHCJS/DOM/JSFFI/Generated/RTCDataChannelEvent.hs b/src/GHCJS/DOM/JSFFI/Generated/RTCDataChannelEvent.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/RTCDataChannelEvent.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/RTCDataChannelEvent.hs
@@ -1,10 +1,15 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.RTCDataChannelEvent
-       (js_getChannel, getChannel, getChannelUnchecked,
-        RTCDataChannelEvent, castToRTCDataChannelEvent,
-        gTypeRTCDataChannelEvent)
+       (js_getChannel, getChannel, getChannelUnsafe, getChannelUnchecked,
+        RTCDataChannelEvent(..), gTypeRTCDataChannelEvent)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -20,6 +25,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"channel\"]" js_getChannel ::
         RTCDataChannelEvent -> IO (Nullable RTCDataChannel)
@@ -29,6 +44,15 @@
            (MonadIO m) => RTCDataChannelEvent -> m (Maybe RTCDataChannel)
 getChannel self
   = liftIO (nullableToMaybe <$> (js_getChannel (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/RTCDataChannelEvent.channel Mozilla RTCDataChannelEvent.channel documentation> 
+getChannelUnsafe ::
+                 (MonadIO m, HasCallStack) =>
+                   RTCDataChannelEvent -> m RTCDataChannel
+getChannelUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getChannel (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/RTCDataChannelEvent.channel Mozilla RTCDataChannelEvent.channel documentation> 
 getChannelUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/RTCIceCandidate.hs b/src/GHCJS/DOM/JSFFI/Generated/RTCIceCandidate.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/RTCIceCandidate.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/RTCIceCandidate.hs
@@ -1,11 +1,16 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.RTCIceCandidate
        (js_newRTCIceCandidate, newRTCIceCandidate, js_getCandidate,
         getCandidate, js_getSdpMid, getSdpMid, js_getSdpMLineIndex,
-        getSdpMLineIndex, RTCIceCandidate, castToRTCIceCandidate,
-        gTypeRTCIceCandidate)
+        getSdpMLineIndex, RTCIceCandidate(..), gTypeRTCIceCandidate)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -21,6 +26,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe
         "new window[\"RTCIceCandidate\"]($1)" js_newRTCIceCandidate ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/RTCIceCandidateEvent.hs b/src/GHCJS/DOM/JSFFI/Generated/RTCIceCandidateEvent.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/RTCIceCandidateEvent.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/RTCIceCandidateEvent.hs
@@ -1,10 +1,16 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.RTCIceCandidateEvent
-       (js_getCandidate, getCandidate, getCandidateUnchecked,
-        RTCIceCandidateEvent, castToRTCIceCandidateEvent,
+       (js_getCandidate, getCandidate, getCandidateUnsafe,
+        getCandidateUnchecked, RTCIceCandidateEvent(..),
         gTypeRTCIceCandidateEvent)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -20,6 +26,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"candidate\"]"
         js_getCandidate ::
@@ -30,6 +46,15 @@
              (MonadIO m) => RTCIceCandidateEvent -> m (Maybe RTCIceCandidate)
 getCandidate self
   = liftIO (nullableToMaybe <$> (js_getCandidate (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/RTCIceCandidateEvent.candidate Mozilla RTCIceCandidateEvent.candidate documentation> 
+getCandidateUnsafe ::
+                   (MonadIO m, HasCallStack) =>
+                     RTCIceCandidateEvent -> m RTCIceCandidate
+getCandidateUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getCandidate (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/RTCIceCandidateEvent.candidate Mozilla RTCIceCandidateEvent.candidate documentation> 
 getCandidateUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/RTCIceServer.hs b/src/GHCJS/DOM/JSFFI/Generated/RTCIceServer.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/RTCIceServer.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/RTCIceServer.hs
@@ -1,10 +1,16 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.RTCIceServer
        (js_getUrls, getUrls, js_getUsername, getUsername,
-        js_getCredential, getCredential, RTCIceServer, castToRTCIceServer,
+        js_getCredential, getCredential, RTCIceServer(..),
         gTypeRTCIceServer)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -20,6 +26,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"urls\"]" js_getUrls ::
         RTCIceServer -> IO JSVal
diff --git a/src/GHCJS/DOM/JSFFI/Generated/RTCPeerConnection.hs b/src/GHCJS/DOM/JSFFI/Generated/RTCPeerConnection.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/RTCPeerConnection.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/RTCPeerConnection.hs
@@ -1,4 +1,9 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.RTCPeerConnection
        (js_newRTCPeerConnection, newRTCPeerConnection, js_createOffer,
         createOffer, js_createAnswer, createAnswer, js_setLocalDescription,
@@ -7,23 +12,27 @@
         js_getLocalStreams, getLocalStreams, getLocalStreams_,
         js_getRemoteStreams, getRemoteStreams, getRemoteStreams_,
         js_getStreamById, getStreamById, getStreamById_,
-        getStreamByIdUnchecked, js_getConfiguration, getConfiguration,
-        getConfiguration_, getConfigurationUnchecked, js_addStream,
-        addStream, js_removeStream, removeStream, js_getStats, getStats,
+        getStreamByIdUnsafe, getStreamByIdUnchecked, js_getConfiguration,
+        getConfiguration, getConfiguration_, getConfigurationUnsafe,
+        getConfigurationUnchecked, js_addStream, addStream,
+        js_removeStream, removeStream, js_getStats, getStats,
         js_createDataChannel, createDataChannel, createDataChannel_,
-        createDataChannelUnchecked, js_createDTMFSender, createDTMFSender,
-        createDTMFSender_, createDTMFSenderUnchecked, js_close, close,
+        createDataChannelUnsafe, createDataChannelUnchecked,
+        js_createDTMFSender, createDTMFSender, createDTMFSender_,
+        createDTMFSenderUnsafe, createDTMFSenderUnchecked, js_close, close,
         js_getLocalDescription, getLocalDescription,
-        getLocalDescriptionUnchecked, js_getRemoteDescription,
-        getRemoteDescription, getRemoteDescriptionUnchecked,
+        getLocalDescriptionUnsafe, getLocalDescriptionUnchecked,
+        js_getRemoteDescription, getRemoteDescription,
+        getRemoteDescriptionUnsafe, getRemoteDescriptionUnchecked,
         js_getSignalingState, getSignalingState, js_getIceGatheringState,
         getIceGatheringState, js_getIceConnectionState,
         getIceConnectionState, negotiationNeeded, iceCandidate,
         signalingStateChange, addStreamEvent, removeStreamEvent,
-        iceConnectionStateChange, dataChannel, RTCPeerConnection,
-        castToRTCPeerConnection, gTypeRTCPeerConnection)
+        iceConnectionStateChange, dataChannel, RTCPeerConnection(..),
+        gTypeRTCPeerConnection)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -39,6 +48,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe
         "new window[\"webkitRTCPeerConnection\"]($1)"
@@ -212,6 +231,16 @@
   = liftIO (void (js_getStreamById (self) (toJSString streamId)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/webkitRTCPeerConnection.getStreamById Mozilla webkitRTCPeerConnection.getStreamById documentation> 
+getStreamByIdUnsafe ::
+                    (MonadIO m, ToJSString streamId, HasCallStack) =>
+                      RTCPeerConnection -> streamId -> m MediaStream
+getStreamByIdUnsafe self streamId
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_getStreamById (self) (toJSString streamId)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/webkitRTCPeerConnection.getStreamById Mozilla webkitRTCPeerConnection.getStreamById documentation> 
 getStreamByIdUnchecked ::
                        (MonadIO m, ToJSString streamId) =>
                          RTCPeerConnection -> streamId -> m MediaStream
@@ -235,6 +264,15 @@
 getConfiguration_ self = liftIO (void (js_getConfiguration (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/webkitRTCPeerConnection.getConfiguration Mozilla webkitRTCPeerConnection.getConfiguration documentation> 
+getConfigurationUnsafe ::
+                       (MonadIO m, HasCallStack) =>
+                         RTCPeerConnection -> m RTCConfiguration
+getConfigurationUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getConfiguration (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/webkitRTCPeerConnection.getConfiguration Mozilla webkitRTCPeerConnection.getConfiguration documentation> 
 getConfigurationUnchecked ::
                           (MonadIO m) => RTCPeerConnection -> m RTCConfiguration
 getConfigurationUnchecked self
@@ -307,6 +345,19 @@
             (maybeToNullable (fmap toDictionary options))))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/webkitRTCPeerConnection.createDataChannel Mozilla webkitRTCPeerConnection.createDataChannel documentation> 
+createDataChannelUnsafe ::
+                        (MonadIO m, ToJSString label, IsDictionary options,
+                         HasCallStack) =>
+                          RTCPeerConnection ->
+                            Maybe label -> Maybe options -> m RTCDataChannel
+createDataChannelUnsafe self label options
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_createDataChannel (self) (toMaybeJSString label)
+             (maybeToNullable (fmap toDictionary options))))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/webkitRTCPeerConnection.createDataChannel Mozilla webkitRTCPeerConnection.createDataChannel documentation> 
 createDataChannelUnchecked ::
                            (MonadIO m, ToJSString label, IsDictionary options) =>
                              RTCPeerConnection ->
@@ -343,6 +394,17 @@
             (maybeToNullable (fmap toMediaStreamTrack track))))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/webkitRTCPeerConnection.createDTMFSender Mozilla webkitRTCPeerConnection.createDTMFSender documentation> 
+createDTMFSenderUnsafe ::
+                       (MonadIO m, IsMediaStreamTrack track, HasCallStack) =>
+                         RTCPeerConnection -> Maybe track -> m RTCDTMFSender
+createDTMFSenderUnsafe self track
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_createDTMFSender (self)
+             (maybeToNullable (fmap toMediaStreamTrack track))))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/webkitRTCPeerConnection.createDTMFSender Mozilla webkitRTCPeerConnection.createDTMFSender documentation> 
 createDTMFSenderUnchecked ::
                           (MonadIO m, IsMediaStreamTrack track) =>
                             RTCPeerConnection -> Maybe track -> m RTCDTMFSender
@@ -370,6 +432,15 @@
   = liftIO (nullableToMaybe <$> (js_getLocalDescription (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/webkitRTCPeerConnection.localDescription Mozilla webkitRTCPeerConnection.localDescription documentation> 
+getLocalDescriptionUnsafe ::
+                          (MonadIO m, HasCallStack) =>
+                            RTCPeerConnection -> m RTCSessionDescription
+getLocalDescriptionUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getLocalDescription (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/webkitRTCPeerConnection.localDescription Mozilla webkitRTCPeerConnection.localDescription documentation> 
 getLocalDescriptionUnchecked ::
                              (MonadIO m) => RTCPeerConnection -> m RTCSessionDescription
 getLocalDescriptionUnchecked self
@@ -385,6 +456,15 @@
                      (MonadIO m) => RTCPeerConnection -> m (Maybe RTCSessionDescription)
 getRemoteDescription self
   = liftIO (nullableToMaybe <$> (js_getRemoteDescription (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/webkitRTCPeerConnection.remoteDescription Mozilla webkitRTCPeerConnection.remoteDescription documentation> 
+getRemoteDescriptionUnsafe ::
+                           (MonadIO m, HasCallStack) =>
+                             RTCPeerConnection -> m RTCSessionDescription
+getRemoteDescriptionUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getRemoteDescription (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/webkitRTCPeerConnection.remoteDescription Mozilla webkitRTCPeerConnection.remoteDescription documentation> 
 getRemoteDescriptionUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/RTCPeerConnectionErrorCallback.hs b/src/GHCJS/DOM/JSFFI/Generated/RTCPeerConnectionErrorCallback.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/RTCPeerConnectionErrorCallback.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/RTCPeerConnectionErrorCallback.hs
@@ -1,4 +1,9 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.RTCPeerConnectionErrorCallback
        (newRTCPeerConnectionErrorCallback,
         newRTCPeerConnectionErrorCallbackSync,
@@ -6,6 +11,7 @@
         RTCPeerConnectionErrorCallback)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -21,6 +27,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/RTCPeerConnectionErrorCallback Mozilla RTCPeerConnectionErrorCallback documentation> 
 newRTCPeerConnectionErrorCallback ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/RTCSessionDescription.hs b/src/GHCJS/DOM/JSFFI/Generated/RTCSessionDescription.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/RTCSessionDescription.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/RTCSessionDescription.hs
@@ -1,11 +1,16 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.RTCSessionDescription
        (js_newRTCSessionDescription, newRTCSessionDescription, js_setType,
         setType, js_getType, getType, js_setSdp, setSdp, js_getSdp, getSdp,
-        RTCSessionDescription, castToRTCSessionDescription,
-        gTypeRTCSessionDescription)
+        RTCSessionDescription(..), gTypeRTCSessionDescription)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -21,6 +26,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe
         "new window[\"RTCSessionDescription\"]($1)"
diff --git a/src/GHCJS/DOM/JSFFI/Generated/RTCSessionDescriptionCallback.hs b/src/GHCJS/DOM/JSFFI/Generated/RTCSessionDescriptionCallback.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/RTCSessionDescriptionCallback.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/RTCSessionDescriptionCallback.hs
@@ -1,4 +1,9 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.RTCSessionDescriptionCallback
        (newRTCSessionDescriptionCallback,
         newRTCSessionDescriptionCallbackSync,
@@ -6,6 +11,7 @@
         RTCSessionDescriptionCallback)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -21,6 +27,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/RTCSessionDescriptionCallback Mozilla RTCSessionDescriptionCallback documentation> 
 newRTCSessionDescriptionCallback ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/RTCStatsCallback.hs b/src/GHCJS/DOM/JSFFI/Generated/RTCStatsCallback.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/RTCStatsCallback.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/RTCStatsCallback.hs
@@ -1,9 +1,15 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.RTCStatsCallback
        (newRTCStatsCallback, newRTCStatsCallbackSync,
         newRTCStatsCallbackAsync, RTCStatsCallback)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -19,6 +25,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/RTCStatsCallback Mozilla RTCStatsCallback documentation> 
 newRTCStatsCallback ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/RTCStatsReport.hs b/src/GHCJS/DOM/JSFFI/Generated/RTCStatsReport.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/RTCStatsReport.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/RTCStatsReport.hs
@@ -1,12 +1,18 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.RTCStatsReport
        (js_stat, stat, stat_, js_names, names, names_, js_getTimestamp,
-        getTimestamp, getTimestampUnchecked, js_getId, getId, js_getType,
-        getType, js_getLocal, getLocal, getLocalUnchecked, js_getRemote,
-        getRemote, getRemoteUnchecked, RTCStatsReport,
-        castToRTCStatsReport, gTypeRTCStatsReport)
+        getTimestamp, getTimestampUnsafe, getTimestampUnchecked, js_getId,
+        getId, js_getType, getType, js_getLocal, getLocal, getLocalUnsafe,
+        getLocalUnchecked, js_getRemote, getRemote, getRemoteUnsafe,
+        getRemoteUnchecked, RTCStatsReport(..), gTypeRTCStatsReport)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -22,6 +28,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"stat\"]($2)" js_stat ::
         RTCStatsReport -> JSString -> IO JSString
@@ -59,6 +75,14 @@
   = liftIO (nullableToMaybe <$> (js_getTimestamp (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/RTCStatsReport.timestamp Mozilla RTCStatsReport.timestamp documentation> 
+getTimestampUnsafe ::
+                   (MonadIO m, HasCallStack) => RTCStatsReport -> m Date
+getTimestampUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getTimestamp (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/RTCStatsReport.timestamp Mozilla RTCStatsReport.timestamp documentation> 
 getTimestampUnchecked :: (MonadIO m) => RTCStatsReport -> m Date
 getTimestampUnchecked self
   = liftIO (fromJust . nullableToMaybe <$> (js_getTimestamp (self)))
@@ -88,6 +112,14 @@
 getLocal self = liftIO (nullableToMaybe <$> (js_getLocal (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/RTCStatsReport.local Mozilla RTCStatsReport.local documentation> 
+getLocalUnsafe ::
+               (MonadIO m, HasCallStack) => RTCStatsReport -> m RTCStatsReport
+getLocalUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getLocal (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/RTCStatsReport.local Mozilla RTCStatsReport.local documentation> 
 getLocalUnchecked ::
                   (MonadIO m) => RTCStatsReport -> m RTCStatsReport
 getLocalUnchecked self
@@ -100,6 +132,14 @@
 getRemote ::
           (MonadIO m) => RTCStatsReport -> m (Maybe RTCStatsReport)
 getRemote self = liftIO (nullableToMaybe <$> (js_getRemote (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/RTCStatsReport.remote Mozilla RTCStatsReport.remote documentation> 
+getRemoteUnsafe ::
+                (MonadIO m, HasCallStack) => RTCStatsReport -> m RTCStatsReport
+getRemoteUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getRemote (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/RTCStatsReport.remote Mozilla RTCStatsReport.remote documentation> 
 getRemoteUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/RTCStatsResponse.hs b/src/GHCJS/DOM/JSFFI/Generated/RTCStatsResponse.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/RTCStatsResponse.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/RTCStatsResponse.hs
@@ -1,10 +1,16 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.RTCStatsResponse
        (js_result, result, result_, js_namedItem, namedItem, namedItem_,
-        namedItemUnchecked, RTCStatsResponse, castToRTCStatsResponse,
+        namedItemUnsafe, namedItemUnchecked, RTCStatsResponse(..),
         gTypeRTCStatsResponse)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -20,6 +26,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"result\"]()" js_result ::
         RTCStatsResponse -> IO JSVal
@@ -50,6 +66,15 @@
            (MonadIO m, ToJSString name) => RTCStatsResponse -> name -> m ()
 namedItem_ self name
   = liftIO (void (js_namedItem (self) (toJSString name)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/RTCStatsResponse.namedItem Mozilla RTCStatsResponse.namedItem documentation> 
+namedItemUnsafe ::
+                (MonadIO m, ToJSString name, HasCallStack) =>
+                  RTCStatsResponse -> name -> m RTCStatsReport
+namedItemUnsafe self name
+  = liftIO
+      ((nullableToMaybe <$> (js_namedItem (self) (toJSString name))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/RTCStatsResponse.namedItem Mozilla RTCStatsResponse.namedItem documentation> 
 namedItemUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/RadioNodeList.hs b/src/GHCJS/DOM/JSFFI/Generated/RadioNodeList.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/RadioNodeList.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/RadioNodeList.hs
@@ -1,10 +1,16 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.RadioNodeList
-       (js__get, _get, _get_, _getUnchecked, js_setValue, setValue,
-        js_getValue, getValue, RadioNodeList, castToRadioNodeList,
+       (js__get, _get, _get_, _getUnsafe, _getUnchecked, js_setValue,
+        setValue, js_getValue, getValue, RadioNodeList(..),
         gTypeRadioNodeList)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -20,6 +26,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"_get\"]($2)" js__get ::
         RadioNodeList -> Word -> IO (Nullable Node)
@@ -32,6 +48,14 @@
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/RadioNodeList._get Mozilla RadioNodeList._get documentation> 
 _get_ :: (MonadIO m) => RadioNodeList -> Word -> m ()
 _get_ self index = liftIO (void (js__get (self) index))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/RadioNodeList._get Mozilla RadioNodeList._get documentation> 
+_getUnsafe ::
+           (MonadIO m, HasCallStack) => RadioNodeList -> Word -> m Node
+_getUnsafe self index
+  = liftIO
+      ((nullableToMaybe <$> (js__get (self) index)) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/RadioNodeList._get Mozilla RadioNodeList._get documentation> 
 _getUnchecked :: (MonadIO m) => RadioNodeList -> Word -> m Node
diff --git a/src/GHCJS/DOM/JSFFI/Generated/Range.hs b/src/GHCJS/DOM/JSFFI/Generated/Range.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/Range.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/Range.hs
@@ -1,4 +1,9 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.Range
        (js_newRange, newRange, js_setStart, setStart, js_setEnd, setEnd,
         js_setStartBefore, setStartBefore, js_setStartAfter, setStartAfter,
@@ -8,15 +13,18 @@
         js_compareBoundaryPoints, compareBoundaryPoints,
         compareBoundaryPoints_, js_deleteContents, deleteContents,
         js_extractContents, extractContents, extractContents_,
-        extractContentsUnchecked, js_cloneContents, cloneContents,
-        cloneContents_, cloneContentsUnchecked, js_insertNode, insertNode,
+        extractContentsUnsafe, extractContentsUnchecked, js_cloneContents,
+        cloneContents, cloneContents_, cloneContentsUnsafe,
+        cloneContentsUnchecked, js_insertNode, insertNode,
         js_surroundContents, surroundContents, js_cloneRange, cloneRange,
-        cloneRange_, cloneRangeUnchecked, js_toString, toString, toString_,
-        js_detach, detach, js_getClientRects, getClientRects,
-        getClientRects_, getClientRectsUnchecked, js_getBoundingClientRect,
+        cloneRange_, cloneRangeUnsafe, cloneRangeUnchecked, js_toString,
+        toString, toString_, js_detach, detach, js_getClientRects,
+        getClientRects, getClientRects_, getClientRectsUnsafe,
+        getClientRectsUnchecked, js_getBoundingClientRect,
         getBoundingClientRect, getBoundingClientRect_,
-        getBoundingClientRectUnchecked, js_createContextualFragment,
-        createContextualFragment, createContextualFragment_,
+        getBoundingClientRectUnsafe, getBoundingClientRectUnchecked,
+        js_createContextualFragment, createContextualFragment,
+        createContextualFragment_, createContextualFragmentUnsafe,
         createContextualFragmentUnchecked, js_intersectsNode,
         intersectsNode, intersectsNode_, js_compareNode, compareNode,
         compareNode_, js_comparePoint, comparePoint, comparePoint_,
@@ -25,14 +33,16 @@
         pattern END_TO_END, pattern END_TO_START, pattern NODE_BEFORE,
         pattern NODE_AFTER, pattern NODE_BEFORE_AND_AFTER,
         pattern NODE_INSIDE, js_getStartContainer, getStartContainer,
-        getStartContainerUnchecked, js_getStartOffset, getStartOffset,
-        js_getEndContainer, getEndContainer, getEndContainerUnchecked,
+        getStartContainerUnsafe, getStartContainerUnchecked,
+        js_getStartOffset, getStartOffset, js_getEndContainer,
+        getEndContainer, getEndContainerUnsafe, getEndContainerUnchecked,
         js_getEndOffset, getEndOffset, js_getCollapsed, getCollapsed,
         js_getCommonAncestorContainer, getCommonAncestorContainer,
-        getCommonAncestorContainerUnchecked, Range, castToRange,
-        gTypeRange)
+        getCommonAncestorContainerUnsafe,
+        getCommonAncestorContainerUnchecked, Range(..), gTypeRange)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -48,6 +58,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "new window[\"Range\"]()"
         js_newRange :: IO Range
@@ -187,6 +207,14 @@
 extractContents_ self = liftIO (void (js_extractContents (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Range.extractContents Mozilla Range.extractContents documentation> 
+extractContentsUnsafe ::
+                      (MonadIO m, HasCallStack) => Range -> m DocumentFragment
+extractContentsUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_extractContents (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Range.extractContents Mozilla Range.extractContents documentation> 
 extractContentsUnchecked ::
                          (MonadIO m) => Range -> m DocumentFragment
 extractContentsUnchecked self
@@ -206,6 +234,14 @@
 cloneContents_ self = liftIO (void (js_cloneContents (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Range.cloneContents Mozilla Range.cloneContents documentation> 
+cloneContentsUnsafe ::
+                    (MonadIO m, HasCallStack) => Range -> m DocumentFragment
+cloneContentsUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_cloneContents (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Range.cloneContents Mozilla Range.cloneContents documentation> 
 cloneContentsUnchecked ::
                        (MonadIO m) => Range -> m DocumentFragment
 cloneContentsUnchecked self
@@ -245,6 +281,13 @@
 cloneRange_ self = liftIO (void (js_cloneRange (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Range.cloneRange Mozilla Range.cloneRange documentation> 
+cloneRangeUnsafe :: (MonadIO m, HasCallStack) => Range -> m Range
+cloneRangeUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_cloneRange (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Range.cloneRange Mozilla Range.cloneRange documentation> 
 cloneRangeUnchecked :: (MonadIO m) => Range -> m Range
 cloneRangeUnchecked self
   = liftIO (fromJust . nullableToMaybe <$> (js_cloneRange (self)))
@@ -280,6 +323,14 @@
 getClientRects_ self = liftIO (void (js_getClientRects (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Range.getClientRects Mozilla Range.getClientRects documentation> 
+getClientRectsUnsafe ::
+                     (MonadIO m, HasCallStack) => Range -> m ClientRectList
+getClientRectsUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getClientRects (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Range.getClientRects Mozilla Range.getClientRects documentation> 
 getClientRectsUnchecked :: (MonadIO m) => Range -> m ClientRectList
 getClientRectsUnchecked self
   = liftIO
@@ -300,6 +351,14 @@
   = liftIO (void (js_getBoundingClientRect (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Range.getBoundingClientRect Mozilla Range.getBoundingClientRect documentation> 
+getBoundingClientRectUnsafe ::
+                            (MonadIO m, HasCallStack) => Range -> m ClientRect
+getBoundingClientRectUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getBoundingClientRect (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Range.getBoundingClientRect Mozilla Range.getBoundingClientRect documentation> 
 getBoundingClientRectUnchecked ::
                                (MonadIO m) => Range -> m ClientRect
 getBoundingClientRectUnchecked self
@@ -327,6 +386,16 @@
       (void (js_createContextualFragment (self) (toJSString html)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Range.createContextualFragment Mozilla Range.createContextualFragment documentation> 
+createContextualFragmentUnsafe ::
+                               (MonadIO m, ToJSString html, HasCallStack) =>
+                                 Range -> html -> m DocumentFragment
+createContextualFragmentUnsafe self html
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_createContextualFragment (self) (toJSString html)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Range.createContextualFragment Mozilla Range.createContextualFragment documentation> 
 createContextualFragmentUnchecked ::
                                   (MonadIO m, ToJSString html) =>
                                     Range -> html -> m DocumentFragment
@@ -441,6 +510,14 @@
   = liftIO (nullableToMaybe <$> (js_getStartContainer (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Range.startContainer Mozilla Range.startContainer documentation> 
+getStartContainerUnsafe ::
+                        (MonadIO m, HasCallStack) => Range -> m Node
+getStartContainerUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getStartContainer (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Range.startContainer Mozilla Range.startContainer documentation> 
 getStartContainerUnchecked :: (MonadIO m) => Range -> m Node
 getStartContainerUnchecked self
   = liftIO
@@ -462,6 +539,14 @@
   = liftIO (nullableToMaybe <$> (js_getEndContainer (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Range.endContainer Mozilla Range.endContainer documentation> 
+getEndContainerUnsafe ::
+                      (MonadIO m, HasCallStack) => Range -> m Node
+getEndContainerUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getEndContainer (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Range.endContainer Mozilla Range.endContainer documentation> 
 getEndContainerUnchecked :: (MonadIO m) => Range -> m Node
 getEndContainerUnchecked self
   = liftIO
@@ -490,6 +575,14 @@
 getCommonAncestorContainer self
   = liftIO
       (nullableToMaybe <$> (js_getCommonAncestorContainer (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Range.commonAncestorContainer Mozilla Range.commonAncestorContainer documentation> 
+getCommonAncestorContainerUnsafe ::
+                                 (MonadIO m, HasCallStack) => Range -> m Node
+getCommonAncestorContainerUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getCommonAncestorContainer (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Range.commonAncestorContainer Mozilla Range.commonAncestorContainer documentation> 
 getCommonAncestorContainerUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/ReadableStream.hs b/src/GHCJS/DOM/JSFFI/Generated/ReadableStream.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/ReadableStream.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/ReadableStream.hs
@@ -1,14 +1,21 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.ReadableStream
        (js_newReadableStream, newReadableStream, js_read, read, read_,
-        readUnchecked, js_cancel, cancel, cancel_, cancelUnchecked,
-        js_pipeTo, pipeTo, pipeTo_, pipeToUnchecked, js_pipeThrough,
-        pipeThrough, pipeThrough_, pipeThroughUnchecked, js_getState,
-        getState, js_getClosed, getClosed, getClosedUnchecked, js_getReady,
-        getReady, getReadyUnchecked, ReadableStream, castToReadableStream,
-        gTypeReadableStream)
+        readUnsafe, readUnchecked, js_cancel, cancel, cancel_,
+        cancelUnsafe, cancelUnchecked, js_pipeTo, pipeTo, pipeTo_,
+        pipeToUnsafe, pipeToUnchecked, js_pipeThrough, pipeThrough,
+        pipeThrough_, pipeThroughUnsafe, pipeThroughUnchecked, js_getState,
+        getState, js_getClosed, getClosed, getClosedUnsafe,
+        getClosedUnchecked, js_getReady, getReady, getReadyUnsafe,
+        getReadyUnchecked, ReadableStream(..), gTypeReadableStream)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -24,6 +31,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe
         "new window[\"ReadableStream\"]($1)" js_newReadableStream ::
@@ -46,6 +63,14 @@
 read_ self = liftIO (void (js_read (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream.read Mozilla ReadableStream.read documentation> 
+readUnsafe ::
+           (MonadIO m, HasCallStack) => ReadableStream -> m GObject
+readUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_read (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream.read Mozilla ReadableStream.read documentation> 
 readUnchecked :: (MonadIO m) => ReadableStream -> m GObject
 readUnchecked self
   = liftIO (fromJust . nullableToMaybe <$> (js_read (self)))
@@ -68,6 +93,15 @@
   = liftIO (void (js_cancel (self) (toJSString reason)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream.cancel Mozilla ReadableStream.cancel documentation> 
+cancelUnsafe ::
+             (MonadIO m, ToJSString reason, HasCallStack) =>
+               ReadableStream -> reason -> m Promise
+cancelUnsafe self reason
+  = liftIO
+      ((nullableToMaybe <$> (js_cancel (self) (toJSString reason))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream.cancel Mozilla ReadableStream.cancel documentation> 
 cancelUnchecked ::
                 (MonadIO m, ToJSString reason) =>
                   ReadableStream -> reason -> m Promise
@@ -92,6 +126,15 @@
   = liftIO (void (js_pipeTo (self) streams options))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream.pipeTo Mozilla ReadableStream.pipeTo documentation> 
+pipeToUnsafe ::
+             (MonadIO m, HasCallStack) =>
+               ReadableStream -> JSVal -> JSVal -> m Promise
+pipeToUnsafe self streams options
+  = liftIO
+      ((nullableToMaybe <$> (js_pipeTo (self) streams options)) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream.pipeTo Mozilla ReadableStream.pipeTo documentation> 
 pipeToUnchecked ::
                 (MonadIO m) => ReadableStream -> JSVal -> JSVal -> m Promise
 pipeToUnchecked self streams options
@@ -116,6 +159,15 @@
   = liftIO (void (js_pipeThrough (self) dest options))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream.pipeThrough Mozilla ReadableStream.pipeThrough documentation> 
+pipeThroughUnsafe ::
+                  (MonadIO m, HasCallStack) =>
+                    ReadableStream -> JSVal -> JSVal -> m GObject
+pipeThroughUnsafe self dest options
+  = liftIO
+      ((nullableToMaybe <$> (js_pipeThrough (self) dest options)) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream.pipeThrough Mozilla ReadableStream.pipeThrough documentation> 
 pipeThroughUnchecked ::
                      (MonadIO m) => ReadableStream -> JSVal -> JSVal -> m GObject
 pipeThroughUnchecked self dest options
@@ -140,6 +192,14 @@
 getClosed self = liftIO (nullableToMaybe <$> (js_getClosed (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream.closed Mozilla ReadableStream.closed documentation> 
+getClosedUnsafe ::
+                (MonadIO m, HasCallStack) => ReadableStream -> m Promise
+getClosedUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getClosed (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream.closed Mozilla ReadableStream.closed documentation> 
 getClosedUnchecked :: (MonadIO m) => ReadableStream -> m Promise
 getClosedUnchecked self
   = liftIO (fromJust . nullableToMaybe <$> (js_getClosed (self)))
@@ -150,6 +210,14 @@
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream.ready Mozilla ReadableStream.ready documentation> 
 getReady :: (MonadIO m) => ReadableStream -> m (Maybe Promise)
 getReady self = liftIO (nullableToMaybe <$> (js_getReady (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream.ready Mozilla ReadableStream.ready documentation> 
+getReadyUnsafe ::
+               (MonadIO m, HasCallStack) => ReadableStream -> m Promise
+getReadyUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getReady (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream.ready Mozilla ReadableStream.ready documentation> 
 getReadyUnchecked :: (MonadIO m) => ReadableStream -> m Promise
diff --git a/src/GHCJS/DOM/JSFFI/Generated/Rect.hs b/src/GHCJS/DOM/JSFFI/Generated/Rect.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/Rect.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/Rect.hs
@@ -1,10 +1,17 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.Rect
-       (js_getTop, getTop, getTopUnchecked, js_getRight, getRight,
-        getRightUnchecked, js_getBottom, getBottom, getBottomUnchecked,
-        js_getLeft, getLeft, getLeftUnchecked, Rect, castToRect, gTypeRect)
+       (js_getTop, getTop, getTopUnsafe, getTopUnchecked, js_getRight,
+        getRight, getRightUnsafe, getRightUnchecked, js_getBottom,
+        getBottom, getBottomUnsafe, getBottomUnchecked, js_getLeft,
+        getLeft, getLeftUnsafe, getLeftUnchecked, Rect(..), gTypeRect)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -20,6 +27,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"top\"]" js_getTop ::
         Rect -> IO (Nullable CSSPrimitiveValue)
@@ -29,6 +46,14 @@
 getTop self = liftIO (nullableToMaybe <$> (js_getTop (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Rect.top Mozilla Rect.top documentation> 
+getTopUnsafe ::
+             (MonadIO m, HasCallStack) => Rect -> m CSSPrimitiveValue
+getTopUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getTop (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Rect.top Mozilla Rect.top documentation> 
 getTopUnchecked :: (MonadIO m) => Rect -> m CSSPrimitiveValue
 getTopUnchecked self
   = liftIO (fromJust . nullableToMaybe <$> (js_getTop (self)))
@@ -41,6 +66,14 @@
 getRight self = liftIO (nullableToMaybe <$> (js_getRight (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Rect.right Mozilla Rect.right documentation> 
+getRightUnsafe ::
+               (MonadIO m, HasCallStack) => Rect -> m CSSPrimitiveValue
+getRightUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getRight (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Rect.right Mozilla Rect.right documentation> 
 getRightUnchecked :: (MonadIO m) => Rect -> m CSSPrimitiveValue
 getRightUnchecked self
   = liftIO (fromJust . nullableToMaybe <$> (js_getRight (self)))
@@ -53,6 +86,14 @@
 getBottom self = liftIO (nullableToMaybe <$> (js_getBottom (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Rect.bottom Mozilla Rect.bottom documentation> 
+getBottomUnsafe ::
+                (MonadIO m, HasCallStack) => Rect -> m CSSPrimitiveValue
+getBottomUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getBottom (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Rect.bottom Mozilla Rect.bottom documentation> 
 getBottomUnchecked :: (MonadIO m) => Rect -> m CSSPrimitiveValue
 getBottomUnchecked self
   = liftIO (fromJust . nullableToMaybe <$> (js_getBottom (self)))
@@ -63,6 +104,14 @@
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Rect.left Mozilla Rect.left documentation> 
 getLeft :: (MonadIO m) => Rect -> m (Maybe CSSPrimitiveValue)
 getLeft self = liftIO (nullableToMaybe <$> (js_getLeft (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Rect.left Mozilla Rect.left documentation> 
+getLeftUnsafe ::
+              (MonadIO m, HasCallStack) => Rect -> m CSSPrimitiveValue
+getLeftUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getLeft (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Rect.left Mozilla Rect.left documentation> 
 getLeftUnchecked :: (MonadIO m) => Rect -> m CSSPrimitiveValue
diff --git a/src/GHCJS/DOM/JSFFI/Generated/RequestAnimationFrameCallback.hs b/src/GHCJS/DOM/JSFFI/Generated/RequestAnimationFrameCallback.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/RequestAnimationFrameCallback.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/RequestAnimationFrameCallback.hs
@@ -1,4 +1,9 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.RequestAnimationFrameCallback
        (newRequestAnimationFrameCallback,
         newRequestAnimationFrameCallbackSync,
@@ -6,6 +11,7 @@
         RequestAnimationFrameCallback)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -21,6 +27,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/RequestAnimationFrameCallback Mozilla RequestAnimationFrameCallback documentation> 
 newRequestAnimationFrameCallback ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/SQLError.hs b/src/GHCJS/DOM/JSFFI/Generated/SQLError.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/SQLError.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/SQLError.hs
@@ -1,11 +1,17 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.SQLError
        (pattern UNKNOWN_ERR, pattern DATABASE_ERR, pattern VERSION_ERR,
         pattern TOO_LARGE_ERR, pattern QUOTA_ERR, pattern SYNTAX_ERR,
         pattern CONSTRAINT_ERR, pattern TIMEOUT_ERR, js_getCode, getCode,
-        js_getMessage, getMessage, SQLError, castToSQLError, gTypeSQLError)
+        js_getMessage, getMessage, SQLError(..), gTypeSQLError)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -21,6 +27,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
 pattern UNKNOWN_ERR = 0
 pattern DATABASE_ERR = 1
 pattern VERSION_ERR = 2
diff --git a/src/GHCJS/DOM/JSFFI/Generated/SQLResultSet.hs b/src/GHCJS/DOM/JSFFI/Generated/SQLResultSet.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/SQLResultSet.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/SQLResultSet.hs
@@ -1,10 +1,16 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.SQLResultSet
-       (js_getRows, getRows, getRowsUnchecked, js_getInsertId,
-        getInsertId, js_getRowsAffected, getRowsAffected, SQLResultSet,
-        castToSQLResultSet, gTypeSQLResultSet)
+       (js_getRows, getRows, getRowsUnsafe, getRowsUnchecked,
+        js_getInsertId, getInsertId, js_getRowsAffected, getRowsAffected,
+        SQLResultSet(..), gTypeSQLResultSet)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -20,6 +26,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"rows\"]" js_getRows ::
         SQLResultSet -> IO (Nullable SQLResultSetRowList)
@@ -28,6 +44,14 @@
 getRows ::
         (MonadIO m) => SQLResultSet -> m (Maybe SQLResultSetRowList)
 getRows self = liftIO (nullableToMaybe <$> (js_getRows (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SQLResultSet.rows Mozilla SQLResultSet.rows documentation> 
+getRowsUnsafe ::
+              (MonadIO m, HasCallStack) => SQLResultSet -> m SQLResultSetRowList
+getRowsUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getRows (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SQLResultSet.rows Mozilla SQLResultSet.rows documentation> 
 getRowsUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/SQLResultSetRowList.hs b/src/GHCJS/DOM/JSFFI/Generated/SQLResultSetRowList.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/SQLResultSetRowList.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/SQLResultSetRowList.hs
@@ -1,10 +1,15 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.SQLResultSetRowList
        (js_item, item, item_, js_getLength, getLength,
-        SQLResultSetRowList, castToSQLResultSetRowList,
-        gTypeSQLResultSetRowList)
+        SQLResultSetRowList(..), gTypeSQLResultSetRowList)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -20,6 +25,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"item\"]($2)" js_item ::
         SQLResultSetRowList -> Word -> IO JSVal
diff --git a/src/GHCJS/DOM/JSFFI/Generated/SQLStatementCallback.hs b/src/GHCJS/DOM/JSFFI/Generated/SQLStatementCallback.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/SQLStatementCallback.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/SQLStatementCallback.hs
@@ -1,9 +1,15 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.SQLStatementCallback
        (newSQLStatementCallback, newSQLStatementCallbackSync,
         newSQLStatementCallbackAsync, SQLStatementCallback)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -19,6 +25,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SQLStatementCallback Mozilla SQLStatementCallback documentation> 
 newSQLStatementCallback ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/SQLStatementErrorCallback.hs b/src/GHCJS/DOM/JSFFI/Generated/SQLStatementErrorCallback.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/SQLStatementErrorCallback.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/SQLStatementErrorCallback.hs
@@ -1,9 +1,15 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.SQLStatementErrorCallback
        (newSQLStatementErrorCallback, newSQLStatementErrorCallbackSync,
         newSQLStatementErrorCallbackAsync, SQLStatementErrorCallback)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -19,6 +25,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SQLStatementErrorCallback Mozilla SQLStatementErrorCallback documentation> 
 newSQLStatementErrorCallback ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/SQLTransaction.hs b/src/GHCJS/DOM/JSFFI/Generated/SQLTransaction.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/SQLTransaction.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/SQLTransaction.hs
@@ -1,9 +1,15 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.SQLTransaction
-       (js_executeSql, executeSql, SQLTransaction, castToSQLTransaction,
+       (js_executeSql, executeSql, SQLTransaction(..),
         gTypeSQLTransaction)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -19,6 +25,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe
         "$1[\"executeSql\"]($2, $3, $4, $5)" js_executeSql ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/SQLTransactionCallback.hs b/src/GHCJS/DOM/JSFFI/Generated/SQLTransactionCallback.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/SQLTransactionCallback.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/SQLTransactionCallback.hs
@@ -1,9 +1,15 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.SQLTransactionCallback
        (newSQLTransactionCallback, newSQLTransactionCallbackSync,
         newSQLTransactionCallbackAsync, SQLTransactionCallback)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -19,6 +25,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SQLTransactionCallback Mozilla SQLTransactionCallback documentation> 
 newSQLTransactionCallback ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/SQLTransactionErrorCallback.hs b/src/GHCJS/DOM/JSFFI/Generated/SQLTransactionErrorCallback.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/SQLTransactionErrorCallback.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/SQLTransactionErrorCallback.hs
@@ -1,10 +1,16 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.SQLTransactionErrorCallback
        (newSQLTransactionErrorCallback,
         newSQLTransactionErrorCallbackSync,
         newSQLTransactionErrorCallbackAsync, SQLTransactionErrorCallback)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -20,6 +26,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SQLTransactionErrorCallback Mozilla SQLTransactionErrorCallback documentation> 
 newSQLTransactionErrorCallback ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/SVGAElement.hs b/src/GHCJS/DOM/JSFFI/Generated/SVGAElement.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/SVGAElement.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/SVGAElement.hs
@@ -1,9 +1,15 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.SVGAElement
-       (js_getTarget, getTarget, getTargetUnchecked, SVGAElement,
-        castToSVGAElement, gTypeSVGAElement)
+       (js_getTarget, getTarget, getTargetUnsafe, getTargetUnchecked,
+        SVGAElement(..), gTypeSVGAElement)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -19,6 +25,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"target\"]" js_getTarget ::
         SVGAElement -> IO (Nullable SVGAnimatedString)
@@ -27,6 +43,14 @@
 getTarget ::
           (MonadIO m) => SVGAElement -> m (Maybe SVGAnimatedString)
 getTarget self = liftIO (nullableToMaybe <$> (js_getTarget (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGAElement.target Mozilla SVGAElement.target documentation> 
+getTargetUnsafe ::
+                (MonadIO m, HasCallStack) => SVGAElement -> m SVGAnimatedString
+getTargetUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getTarget (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGAElement.target Mozilla SVGAElement.target documentation> 
 getTargetUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/SVGAltGlyphElement.hs b/src/GHCJS/DOM/JSFFI/Generated/SVGAltGlyphElement.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/SVGAltGlyphElement.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/SVGAltGlyphElement.hs
@@ -1,11 +1,16 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.SVGAltGlyphElement
        (js_setGlyphRef, setGlyphRef, js_getGlyphRef, getGlyphRef,
         js_setFormat, setFormat, js_getFormat, getFormat,
-        SVGAltGlyphElement, castToSVGAltGlyphElement,
-        gTypeSVGAltGlyphElement)
+        SVGAltGlyphElement(..), gTypeSVGAltGlyphElement)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -21,6 +26,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"glyphRef\"] = $2;"
         js_setGlyphRef :: SVGAltGlyphElement -> JSString -> IO ()
diff --git a/src/GHCJS/DOM/JSFFI/Generated/SVGAngle.hs b/src/GHCJS/DOM/JSFFI/Generated/SVGAngle.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/SVGAngle.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/SVGAngle.hs
@@ -1,4 +1,9 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.SVGAngle
        (js_newValueSpecifiedUnits, newValueSpecifiedUnits,
         js_convertToSpecifiedUnits, convertToSpecifiedUnits,
@@ -9,10 +14,11 @@
         js_setValueInSpecifiedUnits, setValueInSpecifiedUnits,
         js_getValueInSpecifiedUnits, getValueInSpecifiedUnits,
         js_setValueAsString, setValueAsString, js_getValueAsString,
-        getValueAsString, getValueAsStringUnchecked, SVGAngle,
-        castToSVGAngle, gTypeSVGAngle)
+        getValueAsString, getValueAsStringUnsafe,
+        getValueAsStringUnchecked, SVGAngle(..), gTypeSVGAngle)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -28,6 +34,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe
         "$1[\"newValueSpecifiedUnits\"]($2,\n$3)" js_newValueSpecifiedUnits
@@ -110,6 +126,15 @@
                  (MonadIO m, FromJSString result) => SVGAngle -> m (Maybe result)
 getValueAsString self
   = liftIO (fromMaybeJSString <$> (js_getValueAsString (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGAngle.valueAsString Mozilla SVGAngle.valueAsString documentation> 
+getValueAsStringUnsafe ::
+                       (MonadIO m, HasCallStack, FromJSString result) =>
+                         SVGAngle -> m result
+getValueAsStringUnsafe self
+  = liftIO
+      ((fromMaybeJSString <$> (js_getValueAsString (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGAngle.valueAsString Mozilla SVGAngle.valueAsString documentation> 
 getValueAsStringUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/SVGAnimatedAngle.hs b/src/GHCJS/DOM/JSFFI/Generated/SVGAnimatedAngle.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/SVGAnimatedAngle.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/SVGAnimatedAngle.hs
@@ -1,10 +1,16 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.SVGAnimatedAngle
-       (js_getBaseVal, getBaseVal, getBaseValUnchecked, js_getAnimVal,
-        getAnimVal, getAnimValUnchecked, SVGAnimatedAngle,
-        castToSVGAnimatedAngle, gTypeSVGAnimatedAngle)
+       (js_getBaseVal, getBaseVal, getBaseValUnsafe, getBaseValUnchecked,
+        js_getAnimVal, getAnimVal, getAnimValUnsafe, getAnimValUnchecked,
+        SVGAnimatedAngle(..), gTypeSVGAnimatedAngle)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -20,6 +26,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"baseVal\"]" js_getBaseVal ::
         SVGAnimatedAngle -> IO (Nullable SVGAngle)
@@ -30,6 +46,14 @@
   = liftIO (nullableToMaybe <$> (js_getBaseVal (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGAnimatedAngle.baseVal Mozilla SVGAnimatedAngle.baseVal documentation> 
+getBaseValUnsafe ::
+                 (MonadIO m, HasCallStack) => SVGAnimatedAngle -> m SVGAngle
+getBaseValUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getBaseVal (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGAnimatedAngle.baseVal Mozilla SVGAnimatedAngle.baseVal documentation> 
 getBaseValUnchecked ::
                     (MonadIO m) => SVGAnimatedAngle -> m SVGAngle
 getBaseValUnchecked self
@@ -42,6 +66,14 @@
 getAnimVal :: (MonadIO m) => SVGAnimatedAngle -> m (Maybe SVGAngle)
 getAnimVal self
   = liftIO (nullableToMaybe <$> (js_getAnimVal (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGAnimatedAngle.animVal Mozilla SVGAnimatedAngle.animVal documentation> 
+getAnimValUnsafe ::
+                 (MonadIO m, HasCallStack) => SVGAnimatedAngle -> m SVGAngle
+getAnimValUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getAnimVal (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGAnimatedAngle.animVal Mozilla SVGAnimatedAngle.animVal documentation> 
 getAnimValUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/SVGAnimatedBoolean.hs b/src/GHCJS/DOM/JSFFI/Generated/SVGAnimatedBoolean.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/SVGAnimatedBoolean.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/SVGAnimatedBoolean.hs
@@ -1,10 +1,16 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.SVGAnimatedBoolean
        (js_setBaseVal, setBaseVal, js_getBaseVal, getBaseVal,
-        js_getAnimVal, getAnimVal, SVGAnimatedBoolean,
-        castToSVGAnimatedBoolean, gTypeSVGAnimatedBoolean)
+        js_getAnimVal, getAnimVal, SVGAnimatedBoolean(..),
+        gTypeSVGAnimatedBoolean)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -20,6 +26,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"baseVal\"] = $2;"
         js_setBaseVal :: SVGAnimatedBoolean -> Bool -> IO ()
diff --git a/src/GHCJS/DOM/JSFFI/Generated/SVGAnimatedEnumeration.hs b/src/GHCJS/DOM/JSFFI/Generated/SVGAnimatedEnumeration.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/SVGAnimatedEnumeration.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/SVGAnimatedEnumeration.hs
@@ -1,10 +1,16 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.SVGAnimatedEnumeration
        (js_setBaseVal, setBaseVal, js_getBaseVal, getBaseVal,
-        js_getAnimVal, getAnimVal, SVGAnimatedEnumeration,
-        castToSVGAnimatedEnumeration, gTypeSVGAnimatedEnumeration)
+        js_getAnimVal, getAnimVal, SVGAnimatedEnumeration(..),
+        gTypeSVGAnimatedEnumeration)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -20,6 +26,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"baseVal\"] = $2;"
         js_setBaseVal :: SVGAnimatedEnumeration -> Word -> IO ()
diff --git a/src/GHCJS/DOM/JSFFI/Generated/SVGAnimatedInteger.hs b/src/GHCJS/DOM/JSFFI/Generated/SVGAnimatedInteger.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/SVGAnimatedInteger.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/SVGAnimatedInteger.hs
@@ -1,10 +1,16 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.SVGAnimatedInteger
        (js_setBaseVal, setBaseVal, js_getBaseVal, getBaseVal,
-        js_getAnimVal, getAnimVal, SVGAnimatedInteger,
-        castToSVGAnimatedInteger, gTypeSVGAnimatedInteger)
+        js_getAnimVal, getAnimVal, SVGAnimatedInteger(..),
+        gTypeSVGAnimatedInteger)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -20,6 +26,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"baseVal\"] = $2;"
         js_setBaseVal :: SVGAnimatedInteger -> Int -> IO ()
diff --git a/src/GHCJS/DOM/JSFFI/Generated/SVGAnimatedLength.hs b/src/GHCJS/DOM/JSFFI/Generated/SVGAnimatedLength.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/SVGAnimatedLength.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/SVGAnimatedLength.hs
@@ -1,10 +1,16 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.SVGAnimatedLength
-       (js_getBaseVal, getBaseVal, getBaseValUnchecked, js_getAnimVal,
-        getAnimVal, getAnimValUnchecked, SVGAnimatedLength,
-        castToSVGAnimatedLength, gTypeSVGAnimatedLength)
+       (js_getBaseVal, getBaseVal, getBaseValUnsafe, getBaseValUnchecked,
+        js_getAnimVal, getAnimVal, getAnimValUnsafe, getAnimValUnchecked,
+        SVGAnimatedLength(..), gTypeSVGAnimatedLength)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -20,6 +26,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"baseVal\"]" js_getBaseVal ::
         SVGAnimatedLength -> IO (Nullable SVGLength)
@@ -31,6 +47,14 @@
   = liftIO (nullableToMaybe <$> (js_getBaseVal (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGAnimatedLength.baseVal Mozilla SVGAnimatedLength.baseVal documentation> 
+getBaseValUnsafe ::
+                 (MonadIO m, HasCallStack) => SVGAnimatedLength -> m SVGLength
+getBaseValUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getBaseVal (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGAnimatedLength.baseVal Mozilla SVGAnimatedLength.baseVal documentation> 
 getBaseValUnchecked ::
                     (MonadIO m) => SVGAnimatedLength -> m SVGLength
 getBaseValUnchecked self
@@ -44,6 +68,14 @@
            (MonadIO m) => SVGAnimatedLength -> m (Maybe SVGLength)
 getAnimVal self
   = liftIO (nullableToMaybe <$> (js_getAnimVal (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGAnimatedLength.animVal Mozilla SVGAnimatedLength.animVal documentation> 
+getAnimValUnsafe ::
+                 (MonadIO m, HasCallStack) => SVGAnimatedLength -> m SVGLength
+getAnimValUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getAnimVal (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGAnimatedLength.animVal Mozilla SVGAnimatedLength.animVal documentation> 
 getAnimValUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/SVGAnimatedLengthList.hs b/src/GHCJS/DOM/JSFFI/Generated/SVGAnimatedLengthList.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/SVGAnimatedLengthList.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/SVGAnimatedLengthList.hs
@@ -1,10 +1,16 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.SVGAnimatedLengthList
-       (js_getBaseVal, getBaseVal, getBaseValUnchecked, js_getAnimVal,
-        getAnimVal, getAnimValUnchecked, SVGAnimatedLengthList,
-        castToSVGAnimatedLengthList, gTypeSVGAnimatedLengthList)
+       (js_getBaseVal, getBaseVal, getBaseValUnsafe, getBaseValUnchecked,
+        js_getAnimVal, getAnimVal, getAnimValUnsafe, getAnimValUnchecked,
+        SVGAnimatedLengthList(..), gTypeSVGAnimatedLengthList)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -20,6 +26,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"baseVal\"]" js_getBaseVal ::
         SVGAnimatedLengthList -> IO (Nullable SVGLengthList)
@@ -31,6 +47,15 @@
   = liftIO (nullableToMaybe <$> (js_getBaseVal (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGAnimatedLengthList.baseVal Mozilla SVGAnimatedLengthList.baseVal documentation> 
+getBaseValUnsafe ::
+                 (MonadIO m, HasCallStack) =>
+                   SVGAnimatedLengthList -> m SVGLengthList
+getBaseValUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getBaseVal (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGAnimatedLengthList.baseVal Mozilla SVGAnimatedLengthList.baseVal documentation> 
 getBaseValUnchecked ::
                     (MonadIO m) => SVGAnimatedLengthList -> m SVGLengthList
 getBaseValUnchecked self
@@ -44,6 +69,15 @@
            (MonadIO m) => SVGAnimatedLengthList -> m (Maybe SVGLengthList)
 getAnimVal self
   = liftIO (nullableToMaybe <$> (js_getAnimVal (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGAnimatedLengthList.animVal Mozilla SVGAnimatedLengthList.animVal documentation> 
+getAnimValUnsafe ::
+                 (MonadIO m, HasCallStack) =>
+                   SVGAnimatedLengthList -> m SVGLengthList
+getAnimValUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getAnimVal (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGAnimatedLengthList.animVal Mozilla SVGAnimatedLengthList.animVal documentation> 
 getAnimValUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/SVGAnimatedNumber.hs b/src/GHCJS/DOM/JSFFI/Generated/SVGAnimatedNumber.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/SVGAnimatedNumber.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/SVGAnimatedNumber.hs
@@ -1,10 +1,16 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.SVGAnimatedNumber
        (js_setBaseVal, setBaseVal, js_getBaseVal, getBaseVal,
-        js_getAnimVal, getAnimVal, SVGAnimatedNumber,
-        castToSVGAnimatedNumber, gTypeSVGAnimatedNumber)
+        js_getAnimVal, getAnimVal, SVGAnimatedNumber(..),
+        gTypeSVGAnimatedNumber)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -20,6 +26,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"baseVal\"] = $2;"
         js_setBaseVal :: SVGAnimatedNumber -> Float -> IO ()
diff --git a/src/GHCJS/DOM/JSFFI/Generated/SVGAnimatedNumberList.hs b/src/GHCJS/DOM/JSFFI/Generated/SVGAnimatedNumberList.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/SVGAnimatedNumberList.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/SVGAnimatedNumberList.hs
@@ -1,10 +1,16 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.SVGAnimatedNumberList
-       (js_getBaseVal, getBaseVal, getBaseValUnchecked, js_getAnimVal,
-        getAnimVal, getAnimValUnchecked, SVGAnimatedNumberList,
-        castToSVGAnimatedNumberList, gTypeSVGAnimatedNumberList)
+       (js_getBaseVal, getBaseVal, getBaseValUnsafe, getBaseValUnchecked,
+        js_getAnimVal, getAnimVal, getAnimValUnsafe, getAnimValUnchecked,
+        SVGAnimatedNumberList(..), gTypeSVGAnimatedNumberList)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -20,6 +26,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"baseVal\"]" js_getBaseVal ::
         SVGAnimatedNumberList -> IO (Nullable SVGNumberList)
@@ -31,6 +47,15 @@
   = liftIO (nullableToMaybe <$> (js_getBaseVal (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGAnimatedNumberList.baseVal Mozilla SVGAnimatedNumberList.baseVal documentation> 
+getBaseValUnsafe ::
+                 (MonadIO m, HasCallStack) =>
+                   SVGAnimatedNumberList -> m SVGNumberList
+getBaseValUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getBaseVal (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGAnimatedNumberList.baseVal Mozilla SVGAnimatedNumberList.baseVal documentation> 
 getBaseValUnchecked ::
                     (MonadIO m) => SVGAnimatedNumberList -> m SVGNumberList
 getBaseValUnchecked self
@@ -44,6 +69,15 @@
            (MonadIO m) => SVGAnimatedNumberList -> m (Maybe SVGNumberList)
 getAnimVal self
   = liftIO (nullableToMaybe <$> (js_getAnimVal (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGAnimatedNumberList.animVal Mozilla SVGAnimatedNumberList.animVal documentation> 
+getAnimValUnsafe ::
+                 (MonadIO m, HasCallStack) =>
+                   SVGAnimatedNumberList -> m SVGNumberList
+getAnimValUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getAnimVal (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGAnimatedNumberList.animVal Mozilla SVGAnimatedNumberList.animVal documentation> 
 getAnimValUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/SVGAnimatedPreserveAspectRatio.hs b/src/GHCJS/DOM/JSFFI/Generated/SVGAnimatedPreserveAspectRatio.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/SVGAnimatedPreserveAspectRatio.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/SVGAnimatedPreserveAspectRatio.hs
@@ -1,11 +1,17 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.SVGAnimatedPreserveAspectRatio
-       (js_getBaseVal, getBaseVal, getBaseValUnchecked, js_getAnimVal,
-        getAnimVal, getAnimValUnchecked, SVGAnimatedPreserveAspectRatio,
-        castToSVGAnimatedPreserveAspectRatio,
+       (js_getBaseVal, getBaseVal, getBaseValUnsafe, getBaseValUnchecked,
+        js_getAnimVal, getAnimVal, getAnimValUnsafe, getAnimValUnchecked,
+        SVGAnimatedPreserveAspectRatio(..),
         gTypeSVGAnimatedPreserveAspectRatio)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -21,6 +27,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"baseVal\"]" js_getBaseVal ::
         SVGAnimatedPreserveAspectRatio ->
@@ -34,6 +50,15 @@
   = liftIO (nullableToMaybe <$> (js_getBaseVal (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGAnimatedPreserveAspectRatio.baseVal Mozilla SVGAnimatedPreserveAspectRatio.baseVal documentation> 
+getBaseValUnsafe ::
+                 (MonadIO m, HasCallStack) =>
+                   SVGAnimatedPreserveAspectRatio -> m SVGPreserveAspectRatio
+getBaseValUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getBaseVal (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGAnimatedPreserveAspectRatio.baseVal Mozilla SVGAnimatedPreserveAspectRatio.baseVal documentation> 
 getBaseValUnchecked ::
                     (MonadIO m) =>
                       SVGAnimatedPreserveAspectRatio -> m SVGPreserveAspectRatio
@@ -50,6 +75,15 @@
              SVGAnimatedPreserveAspectRatio -> m (Maybe SVGPreserveAspectRatio)
 getAnimVal self
   = liftIO (nullableToMaybe <$> (js_getAnimVal (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGAnimatedPreserveAspectRatio.animVal Mozilla SVGAnimatedPreserveAspectRatio.animVal documentation> 
+getAnimValUnsafe ::
+                 (MonadIO m, HasCallStack) =>
+                   SVGAnimatedPreserveAspectRatio -> m SVGPreserveAspectRatio
+getAnimValUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getAnimVal (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGAnimatedPreserveAspectRatio.animVal Mozilla SVGAnimatedPreserveAspectRatio.animVal documentation> 
 getAnimValUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/SVGAnimatedRect.hs b/src/GHCJS/DOM/JSFFI/Generated/SVGAnimatedRect.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/SVGAnimatedRect.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/SVGAnimatedRect.hs
@@ -1,10 +1,16 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.SVGAnimatedRect
-       (js_getBaseVal, getBaseVal, getBaseValUnchecked, js_getAnimVal,
-        getAnimVal, getAnimValUnchecked, SVGAnimatedRect,
-        castToSVGAnimatedRect, gTypeSVGAnimatedRect)
+       (js_getBaseVal, getBaseVal, getBaseValUnsafe, getBaseValUnchecked,
+        js_getAnimVal, getAnimVal, getAnimValUnsafe, getAnimValUnchecked,
+        SVGAnimatedRect(..), gTypeSVGAnimatedRect)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -20,6 +26,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"baseVal\"]" js_getBaseVal ::
         SVGAnimatedRect -> IO (Nullable SVGRect)
@@ -30,6 +46,14 @@
   = liftIO (nullableToMaybe <$> (js_getBaseVal (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGAnimatedRect.baseVal Mozilla SVGAnimatedRect.baseVal documentation> 
+getBaseValUnsafe ::
+                 (MonadIO m, HasCallStack) => SVGAnimatedRect -> m SVGRect
+getBaseValUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getBaseVal (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGAnimatedRect.baseVal Mozilla SVGAnimatedRect.baseVal documentation> 
 getBaseValUnchecked :: (MonadIO m) => SVGAnimatedRect -> m SVGRect
 getBaseValUnchecked self
   = liftIO (fromJust . nullableToMaybe <$> (js_getBaseVal (self)))
@@ -41,6 +65,14 @@
 getAnimVal :: (MonadIO m) => SVGAnimatedRect -> m (Maybe SVGRect)
 getAnimVal self
   = liftIO (nullableToMaybe <$> (js_getAnimVal (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGAnimatedRect.animVal Mozilla SVGAnimatedRect.animVal documentation> 
+getAnimValUnsafe ::
+                 (MonadIO m, HasCallStack) => SVGAnimatedRect -> m SVGRect
+getAnimValUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getAnimVal (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGAnimatedRect.animVal Mozilla SVGAnimatedRect.animVal documentation> 
 getAnimValUnchecked :: (MonadIO m) => SVGAnimatedRect -> m SVGRect
diff --git a/src/GHCJS/DOM/JSFFI/Generated/SVGAnimatedString.hs b/src/GHCJS/DOM/JSFFI/Generated/SVGAnimatedString.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/SVGAnimatedString.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/SVGAnimatedString.hs
@@ -1,10 +1,16 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.SVGAnimatedString
        (js_setBaseVal, setBaseVal, js_getBaseVal, getBaseVal,
-        js_getAnimVal, getAnimVal, SVGAnimatedString,
-        castToSVGAnimatedString, gTypeSVGAnimatedString)
+        js_getAnimVal, getAnimVal, SVGAnimatedString(..),
+        gTypeSVGAnimatedString)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -20,6 +26,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"baseVal\"] = $2;"
         js_setBaseVal :: SVGAnimatedString -> JSString -> IO ()
diff --git a/src/GHCJS/DOM/JSFFI/Generated/SVGAnimatedTransformList.hs b/src/GHCJS/DOM/JSFFI/Generated/SVGAnimatedTransformList.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/SVGAnimatedTransformList.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/SVGAnimatedTransformList.hs
@@ -1,10 +1,16 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.SVGAnimatedTransformList
-       (js_getBaseVal, getBaseVal, getBaseValUnchecked, js_getAnimVal,
-        getAnimVal, getAnimValUnchecked, SVGAnimatedTransformList,
-        castToSVGAnimatedTransformList, gTypeSVGAnimatedTransformList)
+       (js_getBaseVal, getBaseVal, getBaseValUnsafe, getBaseValUnchecked,
+        js_getAnimVal, getAnimVal, getAnimValUnsafe, getAnimValUnchecked,
+        SVGAnimatedTransformList(..), gTypeSVGAnimatedTransformList)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -20,6 +26,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"baseVal\"]" js_getBaseVal ::
         SVGAnimatedTransformList -> IO (Nullable SVGTransformList)
@@ -32,6 +48,15 @@
   = liftIO (nullableToMaybe <$> (js_getBaseVal (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGAnimatedTransformList.baseVal Mozilla SVGAnimatedTransformList.baseVal documentation> 
+getBaseValUnsafe ::
+                 (MonadIO m, HasCallStack) =>
+                   SVGAnimatedTransformList -> m SVGTransformList
+getBaseValUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getBaseVal (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGAnimatedTransformList.baseVal Mozilla SVGAnimatedTransformList.baseVal documentation> 
 getBaseValUnchecked ::
                     (MonadIO m) => SVGAnimatedTransformList -> m SVGTransformList
 getBaseValUnchecked self
@@ -46,6 +71,15 @@
              SVGAnimatedTransformList -> m (Maybe SVGTransformList)
 getAnimVal self
   = liftIO (nullableToMaybe <$> (js_getAnimVal (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGAnimatedTransformList.animVal Mozilla SVGAnimatedTransformList.animVal documentation> 
+getAnimValUnsafe ::
+                 (MonadIO m, HasCallStack) =>
+                   SVGAnimatedTransformList -> m SVGTransformList
+getAnimValUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getAnimVal (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGAnimatedTransformList.animVal Mozilla SVGAnimatedTransformList.animVal documentation> 
 getAnimValUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/SVGAnimationElement.hs b/src/GHCJS/DOM/JSFFI/Generated/SVGAnimationElement.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/SVGAnimationElement.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/SVGAnimationElement.hs
@@ -1,15 +1,22 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.SVGAnimationElement
        (js_getStartTime, getStartTime, getStartTime_, js_getCurrentTime,
         getCurrentTime, getCurrentTime_, js_getSimpleDuration,
         getSimpleDuration, getSimpleDuration_, js_beginElement,
         beginElement, js_beginElementAt, beginElementAt, js_endElement,
         endElement, js_endElementAt, endElementAt, js_getTargetElement,
-        getTargetElement, getTargetElementUnchecked, SVGAnimationElement,
-        castToSVGAnimationElement, gTypeSVGAnimationElement,
-        IsSVGAnimationElement, toSVGAnimationElement)
+        getTargetElement, getTargetElementUnsafe,
+        getTargetElementUnchecked, SVGAnimationElement(..),
+        gTypeSVGAnimationElement, IsSVGAnimationElement,
+        toSVGAnimationElement)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -25,6 +32,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"getStartTime\"]()"
         js_getStartTime :: SVGAnimationElement -> IO Float
@@ -119,6 +136,16 @@
   = liftIO
       (nullableToMaybe <$>
          (js_getTargetElement (toSVGAnimationElement self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGAnimationElement.targetElement Mozilla SVGAnimationElement.targetElement documentation> 
+getTargetElementUnsafe ::
+                       (MonadIO m, IsSVGAnimationElement self, HasCallStack) =>
+                         self -> m SVGElement
+getTargetElementUnsafe self
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_getTargetElement (toSVGAnimationElement self)))
+         >>= maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGAnimationElement.targetElement Mozilla SVGAnimationElement.targetElement documentation> 
 getTargetElementUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/SVGCircleElement.hs b/src/GHCJS/DOM/JSFFI/Generated/SVGCircleElement.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/SVGCircleElement.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/SVGCircleElement.hs
@@ -1,10 +1,16 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.SVGCircleElement
-       (js_getCx, getCx, getCxUnchecked, js_getCy, getCy, getCyUnchecked,
-        js_getR, getR, getRUnchecked, SVGCircleElement,
-        castToSVGCircleElement, gTypeSVGCircleElement)
+       (js_getCx, getCx, getCxUnsafe, getCxUnchecked, js_getCy, getCy,
+        getCyUnsafe, getCyUnchecked, js_getR, getR, getRUnsafe,
+        getRUnchecked, SVGCircleElement(..), gTypeSVGCircleElement)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -20,6 +26,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"cx\"]" js_getCx ::
         SVGCircleElement -> IO (Nullable SVGAnimatedLength)
@@ -30,6 +46,15 @@
 getCx self = liftIO (nullableToMaybe <$> (js_getCx (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGCircleElement.cx Mozilla SVGCircleElement.cx documentation> 
+getCxUnsafe ::
+            (MonadIO m, HasCallStack) =>
+              SVGCircleElement -> m SVGAnimatedLength
+getCxUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getCx (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGCircleElement.cx Mozilla SVGCircleElement.cx documentation> 
 getCxUnchecked ::
                (MonadIO m) => SVGCircleElement -> m SVGAnimatedLength
 getCxUnchecked self
@@ -44,6 +69,15 @@
 getCy self = liftIO (nullableToMaybe <$> (js_getCy (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGCircleElement.cy Mozilla SVGCircleElement.cy documentation> 
+getCyUnsafe ::
+            (MonadIO m, HasCallStack) =>
+              SVGCircleElement -> m SVGAnimatedLength
+getCyUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getCy (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGCircleElement.cy Mozilla SVGCircleElement.cy documentation> 
 getCyUnchecked ::
                (MonadIO m) => SVGCircleElement -> m SVGAnimatedLength
 getCyUnchecked self
@@ -56,6 +90,15 @@
 getR ::
      (MonadIO m) => SVGCircleElement -> m (Maybe SVGAnimatedLength)
 getR self = liftIO (nullableToMaybe <$> (js_getR (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGCircleElement.r Mozilla SVGCircleElement.r documentation> 
+getRUnsafe ::
+           (MonadIO m, HasCallStack) =>
+             SVGCircleElement -> m SVGAnimatedLength
+getRUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getR (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGCircleElement.r Mozilla SVGCircleElement.r documentation> 
 getRUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/SVGClipPathElement.hs b/src/GHCJS/DOM/JSFFI/Generated/SVGClipPathElement.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/SVGClipPathElement.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/SVGClipPathElement.hs
@@ -1,10 +1,16 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.SVGClipPathElement
-       (js_getClipPathUnits, getClipPathUnits, getClipPathUnitsUnchecked,
-        SVGClipPathElement, castToSVGClipPathElement,
+       (js_getClipPathUnits, getClipPathUnits, getClipPathUnitsUnsafe,
+        getClipPathUnitsUnchecked, SVGClipPathElement(..),
         gTypeSVGClipPathElement)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -20,6 +26,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"clipPathUnits\"]"
         js_getClipPathUnits ::
@@ -31,6 +47,15 @@
                    SVGClipPathElement -> m (Maybe SVGAnimatedEnumeration)
 getClipPathUnits self
   = liftIO (nullableToMaybe <$> (js_getClipPathUnits (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGClipPathElement.clipPathUnits Mozilla SVGClipPathElement.clipPathUnits documentation> 
+getClipPathUnitsUnsafe ::
+                       (MonadIO m, HasCallStack) =>
+                         SVGClipPathElement -> m SVGAnimatedEnumeration
+getClipPathUnitsUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getClipPathUnits (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGClipPathElement.clipPathUnits Mozilla SVGClipPathElement.clipPathUnits documentation> 
 getClipPathUnitsUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/SVGColor.hs b/src/GHCJS/DOM/JSFFI/Generated/SVGColor.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/SVGColor.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/SVGColor.hs
@@ -1,14 +1,21 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.SVGColor
        (js_setRGBColor, setRGBColor, js_setRGBColorICCColor,
         setRGBColorICCColor, js_setColor, setColor,
         pattern SVG_COLORTYPE_UNKNOWN, pattern SVG_COLORTYPE_RGBCOLOR,
         pattern SVG_COLORTYPE_RGBCOLOR_ICCCOLOR,
         pattern SVG_COLORTYPE_CURRENTCOLOR, js_getColorType, getColorType,
-        js_getRgbColor, getRgbColor, getRgbColorUnchecked, SVGColor,
-        castToSVGColor, gTypeSVGColor, IsSVGColor, toSVGColor)
+        js_getRgbColor, getRgbColor, getRgbColorUnsafe,
+        getRgbColorUnchecked, SVGColor(..), gTypeSVGColor, IsSVGColor,
+        toSVGColor)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -24,6 +31,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"setRGBColor\"]($2)"
         js_setRGBColor :: SVGColor -> JSString -> IO ()
@@ -81,6 +98,14 @@
             (MonadIO m, IsSVGColor self) => self -> m (Maybe RGBColor)
 getRgbColor self
   = liftIO (nullableToMaybe <$> (js_getRgbColor (toSVGColor self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGColor.rgbColor Mozilla SVGColor.rgbColor documentation> 
+getRgbColorUnsafe ::
+                  (MonadIO m, IsSVGColor self, HasCallStack) => self -> m RGBColor
+getRgbColorUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getRgbColor (toSVGColor self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGColor.rgbColor Mozilla SVGColor.rgbColor documentation> 
 getRgbColorUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/SVGComponentTransferFunctionElement.hs b/src/GHCJS/DOM/JSFFI/Generated/SVGComponentTransferFunctionElement.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/SVGComponentTransferFunctionElement.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/SVGComponentTransferFunctionElement.hs
@@ -1,4 +1,9 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.SVGComponentTransferFunctionElement
        (pattern SVG_FECOMPONENTTRANSFER_TYPE_UNKNOWN,
         pattern SVG_FECOMPONENTTRANSFER_TYPE_IDENTITY,
@@ -6,18 +11,21 @@
         pattern SVG_FECOMPONENTTRANSFER_TYPE_DISCRETE,
         pattern SVG_FECOMPONENTTRANSFER_TYPE_LINEAR,
         pattern SVG_FECOMPONENTTRANSFER_TYPE_GAMMA, js_getType, getType,
-        getTypeUnchecked, js_getTableValues, getTableValues,
-        getTableValuesUnchecked, js_getSlope, getSlope, getSlopeUnchecked,
-        js_getIntercept, getIntercept, getInterceptUnchecked,
-        js_getAmplitude, getAmplitude, getAmplitudeUnchecked,
-        js_getExponent, getExponent, getExponentUnchecked, js_getOffset,
-        getOffset, getOffsetUnchecked, SVGComponentTransferFunctionElement,
-        castToSVGComponentTransferFunctionElement,
+        getTypeUnsafe, getTypeUnchecked, js_getTableValues, getTableValues,
+        getTableValuesUnsafe, getTableValuesUnchecked, js_getSlope,
+        getSlope, getSlopeUnsafe, getSlopeUnchecked, js_getIntercept,
+        getIntercept, getInterceptUnsafe, getInterceptUnchecked,
+        js_getAmplitude, getAmplitude, getAmplitudeUnsafe,
+        getAmplitudeUnchecked, js_getExponent, getExponent,
+        getExponentUnsafe, getExponentUnchecked, js_getOffset, getOffset,
+        getOffsetUnsafe, getOffsetUnchecked,
+        SVGComponentTransferFunctionElement(..),
         gTypeSVGComponentTransferFunctionElement,
         IsSVGComponentTransferFunctionElement,
         toSVGComponentTransferFunctionElement)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -33,6 +41,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
 pattern SVG_FECOMPONENTTRANSFER_TYPE_UNKNOWN = 0
 pattern SVG_FECOMPONENTTRANSFER_TYPE_IDENTITY = 1
 pattern SVG_FECOMPONENTTRANSFER_TYPE_TABLE = 2
@@ -54,6 +72,17 @@
          (js_getType (toSVGComponentTransferFunctionElement self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGComponentTransferFunctionElement.type Mozilla SVGComponentTransferFunctionElement.type documentation> 
+getTypeUnsafe ::
+              (MonadIO m, IsSVGComponentTransferFunctionElement self,
+               HasCallStack) =>
+                self -> m SVGAnimatedEnumeration
+getTypeUnsafe self
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_getType (toSVGComponentTransferFunctionElement self)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGComponentTransferFunctionElement.type Mozilla SVGComponentTransferFunctionElement.type documentation> 
 getTypeUnchecked ::
                  (MonadIO m, IsSVGComponentTransferFunctionElement self) =>
                    self -> m SVGAnimatedEnumeration
@@ -77,6 +106,17 @@
          (js_getTableValues (toSVGComponentTransferFunctionElement self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGComponentTransferFunctionElement.tableValues Mozilla SVGComponentTransferFunctionElement.tableValues documentation> 
+getTableValuesUnsafe ::
+                     (MonadIO m, IsSVGComponentTransferFunctionElement self,
+                      HasCallStack) =>
+                       self -> m SVGAnimatedNumberList
+getTableValuesUnsafe self
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_getTableValues (toSVGComponentTransferFunctionElement self)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGComponentTransferFunctionElement.tableValues Mozilla SVGComponentTransferFunctionElement.tableValues documentation> 
 getTableValuesUnchecked ::
                         (MonadIO m, IsSVGComponentTransferFunctionElement self) =>
                           self -> m SVGAnimatedNumberList
@@ -99,6 +139,17 @@
          (js_getSlope (toSVGComponentTransferFunctionElement self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGComponentTransferFunctionElement.slope Mozilla SVGComponentTransferFunctionElement.slope documentation> 
+getSlopeUnsafe ::
+               (MonadIO m, IsSVGComponentTransferFunctionElement self,
+                HasCallStack) =>
+                 self -> m SVGAnimatedNumber
+getSlopeUnsafe self
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_getSlope (toSVGComponentTransferFunctionElement self)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGComponentTransferFunctionElement.slope Mozilla SVGComponentTransferFunctionElement.slope documentation> 
 getSlopeUnchecked ::
                   (MonadIO m, IsSVGComponentTransferFunctionElement self) =>
                     self -> m SVGAnimatedNumber
@@ -122,6 +173,17 @@
          (js_getIntercept (toSVGComponentTransferFunctionElement self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGComponentTransferFunctionElement.intercept Mozilla SVGComponentTransferFunctionElement.intercept documentation> 
+getInterceptUnsafe ::
+                   (MonadIO m, IsSVGComponentTransferFunctionElement self,
+                    HasCallStack) =>
+                     self -> m SVGAnimatedNumber
+getInterceptUnsafe self
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_getIntercept (toSVGComponentTransferFunctionElement self)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGComponentTransferFunctionElement.intercept Mozilla SVGComponentTransferFunctionElement.intercept documentation> 
 getInterceptUnchecked ::
                       (MonadIO m, IsSVGComponentTransferFunctionElement self) =>
                         self -> m SVGAnimatedNumber
@@ -145,6 +207,17 @@
          (js_getAmplitude (toSVGComponentTransferFunctionElement self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGComponentTransferFunctionElement.amplitude Mozilla SVGComponentTransferFunctionElement.amplitude documentation> 
+getAmplitudeUnsafe ::
+                   (MonadIO m, IsSVGComponentTransferFunctionElement self,
+                    HasCallStack) =>
+                     self -> m SVGAnimatedNumber
+getAmplitudeUnsafe self
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_getAmplitude (toSVGComponentTransferFunctionElement self)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGComponentTransferFunctionElement.amplitude Mozilla SVGComponentTransferFunctionElement.amplitude documentation> 
 getAmplitudeUnchecked ::
                       (MonadIO m, IsSVGComponentTransferFunctionElement self) =>
                         self -> m SVGAnimatedNumber
@@ -168,6 +241,17 @@
          (js_getExponent (toSVGComponentTransferFunctionElement self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGComponentTransferFunctionElement.exponent Mozilla SVGComponentTransferFunctionElement.exponent documentation> 
+getExponentUnsafe ::
+                  (MonadIO m, IsSVGComponentTransferFunctionElement self,
+                   HasCallStack) =>
+                    self -> m SVGAnimatedNumber
+getExponentUnsafe self
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_getExponent (toSVGComponentTransferFunctionElement self)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGComponentTransferFunctionElement.exponent Mozilla SVGComponentTransferFunctionElement.exponent documentation> 
 getExponentUnchecked ::
                      (MonadIO m, IsSVGComponentTransferFunctionElement self) =>
                        self -> m SVGAnimatedNumber
@@ -188,6 +272,17 @@
   = liftIO
       (nullableToMaybe <$>
          (js_getOffset (toSVGComponentTransferFunctionElement self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGComponentTransferFunctionElement.offset Mozilla SVGComponentTransferFunctionElement.offset documentation> 
+getOffsetUnsafe ::
+                (MonadIO m, IsSVGComponentTransferFunctionElement self,
+                 HasCallStack) =>
+                  self -> m SVGAnimatedNumber
+getOffsetUnsafe self
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_getOffset (toSVGComponentTransferFunctionElement self)))
+         >>= maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGComponentTransferFunctionElement.offset Mozilla SVGComponentTransferFunctionElement.offset documentation> 
 getOffsetUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/SVGCursorElement.hs b/src/GHCJS/DOM/JSFFI/Generated/SVGCursorElement.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/SVGCursorElement.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/SVGCursorElement.hs
@@ -1,9 +1,16 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.SVGCursorElement
-       (js_getX, getX, getXUnchecked, js_getY, getY, getYUnchecked,
-        SVGCursorElement, castToSVGCursorElement, gTypeSVGCursorElement)
+       (js_getX, getX, getXUnsafe, getXUnchecked, js_getY, getY,
+        getYUnsafe, getYUnchecked, SVGCursorElement(..),
+        gTypeSVGCursorElement)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -19,6 +26,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"x\"]" js_getX ::
         SVGCursorElement -> IO (Nullable SVGAnimatedLength)
@@ -29,6 +46,15 @@
 getX self = liftIO (nullableToMaybe <$> (js_getX (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGCursorElement.x Mozilla SVGCursorElement.x documentation> 
+getXUnsafe ::
+           (MonadIO m, HasCallStack) =>
+             SVGCursorElement -> m SVGAnimatedLength
+getXUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getX (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGCursorElement.x Mozilla SVGCursorElement.x documentation> 
 getXUnchecked ::
               (MonadIO m) => SVGCursorElement -> m SVGAnimatedLength
 getXUnchecked self
@@ -41,6 +67,15 @@
 getY ::
      (MonadIO m) => SVGCursorElement -> m (Maybe SVGAnimatedLength)
 getY self = liftIO (nullableToMaybe <$> (js_getY (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGCursorElement.y Mozilla SVGCursorElement.y documentation> 
+getYUnsafe ::
+           (MonadIO m, HasCallStack) =>
+             SVGCursorElement -> m SVGAnimatedLength
+getYUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getY (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGCursorElement.y Mozilla SVGCursorElement.y documentation> 
 getYUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/SVGDocument.hs b/src/GHCJS/DOM/JSFFI/Generated/SVGDocument.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/SVGDocument.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/SVGDocument.hs
@@ -1,10 +1,17 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.SVGDocument
-       (js_createEvent, createEvent, createEvent_, createEventUnchecked,
-        js_getRootElement, getRootElement, getRootElementUnchecked,
-        SVGDocument, castToSVGDocument, gTypeSVGDocument)
+       (js_createEvent, createEvent, createEvent_, createEventUnsafe,
+        createEventUnchecked, js_getRootElement, getRootElement,
+        getRootElementUnsafe, getRootElementUnchecked, SVGDocument(..),
+        gTypeSVGDocument)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -20,6 +27,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"createEvent\"]($2)"
         js_createEvent :: SVGDocument -> JSString -> IO (Nullable Event)
@@ -41,6 +58,16 @@
   = liftIO (void (js_createEvent (self) (toJSString eventType)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGDocument.createEvent Mozilla SVGDocument.createEvent documentation> 
+createEventUnsafe ::
+                  (MonadIO m, ToJSString eventType, HasCallStack) =>
+                    SVGDocument -> eventType -> m Event
+createEventUnsafe self eventType
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_createEvent (self) (toJSString eventType)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGDocument.createEvent Mozilla SVGDocument.createEvent documentation> 
 createEventUnchecked ::
                      (MonadIO m, ToJSString eventType) =>
                        SVGDocument -> eventType -> m Event
@@ -57,6 +84,14 @@
                (MonadIO m) => SVGDocument -> m (Maybe SVGSVGElement)
 getRootElement self
   = liftIO (nullableToMaybe <$> (js_getRootElement (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGDocument.rootElement Mozilla SVGDocument.rootElement documentation> 
+getRootElementUnsafe ::
+                     (MonadIO m, HasCallStack) => SVGDocument -> m SVGSVGElement
+getRootElementUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getRootElement (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGDocument.rootElement Mozilla SVGDocument.rootElement documentation> 
 getRootElementUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/SVGElement.hs b/src/GHCJS/DOM/JSFFI/Generated/SVGElement.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/SVGElement.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/SVGElement.hs
@@ -1,19 +1,28 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.SVGElement
        (js_getPresentationAttribute, getPresentationAttribute,
-        getPresentationAttribute_, getPresentationAttributeUnchecked,
-        js_setXmlbase, setXmlbase, js_getXmlbase, getXmlbase,
-        getXmlbaseUnchecked, js_getOwnerSVGElement, getOwnerSVGElement,
-        getOwnerSVGElementUnchecked, js_getViewportElement,
-        getViewportElement, getViewportElementUnchecked, js_setXmllang,
-        setXmllang, js_getXmllang, getXmllang, js_setXmlspace, setXmlspace,
-        js_getXmlspace, getXmlspace, js_getClassName, getClassName,
-        getClassNameUnchecked, js_getStyle, getStyle, getStyleUnchecked,
-        js_setTabIndex, setTabIndex, js_getTabIndex, getTabIndex,
-        SVGElement, castToSVGElement, gTypeSVGElement, IsSVGElement,
+        getPresentationAttribute_, getPresentationAttributeUnsafe,
+        getPresentationAttributeUnchecked, js_setXmlbase, setXmlbase,
+        js_getXmlbase, getXmlbase, getXmlbaseUnsafe, getXmlbaseUnchecked,
+        js_getOwnerSVGElement, getOwnerSVGElement,
+        getOwnerSVGElementUnsafe, getOwnerSVGElementUnchecked,
+        js_getViewportElement, getViewportElement,
+        getViewportElementUnsafe, getViewportElementUnchecked,
+        js_setXmllang, setXmllang, js_getXmllang, getXmllang,
+        js_setXmlspace, setXmlspace, js_getXmlspace, getXmlspace,
+        js_getClassName, getClassName, getClassNameUnsafe,
+        getClassNameUnchecked, js_getStyle, getStyle, getStyleUnsafe,
+        getStyleUnchecked, js_setTabIndex, setTabIndex, js_getTabIndex,
+        getTabIndex, SVGElement(..), gTypeSVGElement, IsSVGElement,
         toSVGElement)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -29,6 +38,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe
         "$1[\"getPresentationAttribute\"]($2)" js_getPresentationAttribute
@@ -55,6 +74,17 @@
             (toJSString name)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGElement.getPresentationAttribute Mozilla SVGElement.getPresentationAttribute documentation> 
+getPresentationAttributeUnsafe ::
+                               (MonadIO m, IsSVGElement self, ToJSString name, HasCallStack) =>
+                                 self -> name -> m CSSValue
+getPresentationAttributeUnsafe self name
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_getPresentationAttribute (toSVGElement self)
+             (toJSString name)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGElement.getPresentationAttribute Mozilla SVGElement.getPresentationAttribute documentation> 
 getPresentationAttributeUnchecked ::
                                   (MonadIO m, IsSVGElement self, ToJSString name) =>
                                     self -> name -> m CSSValue
@@ -86,6 +116,16 @@
       (fromMaybeJSString <$> (js_getXmlbase (toSVGElement self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGElement.xmlbase Mozilla SVGElement.xmlbase documentation> 
+getXmlbaseUnsafe ::
+                 (MonadIO m, IsSVGElement self, HasCallStack,
+                  FromJSString result) =>
+                   self -> m result
+getXmlbaseUnsafe self
+  = liftIO
+      ((fromMaybeJSString <$> (js_getXmlbase (toSVGElement self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGElement.xmlbase Mozilla SVGElement.xmlbase documentation> 
 getXmlbaseUnchecked ::
                     (MonadIO m, IsSVGElement self, FromJSString result) =>
                       self -> m result
@@ -105,6 +145,15 @@
       (nullableToMaybe <$> (js_getOwnerSVGElement (toSVGElement self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGElement.ownerSVGElement Mozilla SVGElement.ownerSVGElement documentation> 
+getOwnerSVGElementUnsafe ::
+                         (MonadIO m, IsSVGElement self, HasCallStack) =>
+                           self -> m SVGSVGElement
+getOwnerSVGElementUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getOwnerSVGElement (toSVGElement self)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGElement.ownerSVGElement Mozilla SVGElement.ownerSVGElement documentation> 
 getOwnerSVGElementUnchecked ::
                             (MonadIO m, IsSVGElement self) => self -> m SVGSVGElement
 getOwnerSVGElementUnchecked self
@@ -123,6 +172,15 @@
       (nullableToMaybe <$> (js_getViewportElement (toSVGElement self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGElement.viewportElement Mozilla SVGElement.viewportElement documentation> 
+getViewportElementUnsafe ::
+                         (MonadIO m, IsSVGElement self, HasCallStack) =>
+                           self -> m SVGElement
+getViewportElementUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getViewportElement (toSVGElement self)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGElement.viewportElement Mozilla SVGElement.viewportElement documentation> 
 getViewportElementUnchecked ::
                             (MonadIO m, IsSVGElement self) => self -> m SVGElement
 getViewportElementUnchecked self
@@ -182,6 +240,15 @@
       (nullableToMaybe <$> (js_getClassName (toSVGElement self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGElement.className Mozilla SVGElement.className documentation> 
+getClassNameUnsafe ::
+                   (MonadIO m, IsSVGElement self, HasCallStack) =>
+                     self -> m SVGAnimatedString
+getClassNameUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getClassName (toSVGElement self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGElement.className Mozilla SVGElement.className documentation> 
 getClassNameUnchecked ::
                       (MonadIO m, IsSVGElement self) => self -> m SVGAnimatedString
 getClassNameUnchecked self
@@ -198,6 +265,15 @@
            self -> m (Maybe CSSStyleDeclaration)
 getStyle self
   = liftIO (nullableToMaybe <$> (js_getStyle (toSVGElement self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGElement.style Mozilla SVGElement.style documentation> 
+getStyleUnsafe ::
+               (MonadIO m, IsSVGElement self, HasCallStack) =>
+                 self -> m CSSStyleDeclaration
+getStyleUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getStyle (toSVGElement self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGElement.style Mozilla SVGElement.style documentation> 
 getStyleUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/SVGEllipseElement.hs b/src/GHCJS/DOM/JSFFI/Generated/SVGEllipseElement.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/SVGEllipseElement.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/SVGEllipseElement.hs
@@ -1,10 +1,17 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.SVGEllipseElement
-       (js_getCx, getCx, getCxUnchecked, js_getCy, getCy, getCyUnchecked,
-        js_getRx, getRx, getRxUnchecked, js_getRy, getRy, getRyUnchecked,
-        SVGEllipseElement, castToSVGEllipseElement, gTypeSVGEllipseElement)
+       (js_getCx, getCx, getCxUnsafe, getCxUnchecked, js_getCy, getCy,
+        getCyUnsafe, getCyUnchecked, js_getRx, getRx, getRxUnsafe,
+        getRxUnchecked, js_getRy, getRy, getRyUnsafe, getRyUnchecked,
+        SVGEllipseElement(..), gTypeSVGEllipseElement)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -20,6 +27,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"cx\"]" js_getCx ::
         SVGEllipseElement -> IO (Nullable SVGAnimatedLength)
@@ -30,6 +47,15 @@
 getCx self = liftIO (nullableToMaybe <$> (js_getCx (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGEllipseElement.cx Mozilla SVGEllipseElement.cx documentation> 
+getCxUnsafe ::
+            (MonadIO m, HasCallStack) =>
+              SVGEllipseElement -> m SVGAnimatedLength
+getCxUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getCx (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGEllipseElement.cx Mozilla SVGEllipseElement.cx documentation> 
 getCxUnchecked ::
                (MonadIO m) => SVGEllipseElement -> m SVGAnimatedLength
 getCxUnchecked self
@@ -44,6 +70,15 @@
 getCy self = liftIO (nullableToMaybe <$> (js_getCy (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGEllipseElement.cy Mozilla SVGEllipseElement.cy documentation> 
+getCyUnsafe ::
+            (MonadIO m, HasCallStack) =>
+              SVGEllipseElement -> m SVGAnimatedLength
+getCyUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getCy (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGEllipseElement.cy Mozilla SVGEllipseElement.cy documentation> 
 getCyUnchecked ::
                (MonadIO m) => SVGEllipseElement -> m SVGAnimatedLength
 getCyUnchecked self
@@ -58,6 +93,15 @@
 getRx self = liftIO (nullableToMaybe <$> (js_getRx (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGEllipseElement.rx Mozilla SVGEllipseElement.rx documentation> 
+getRxUnsafe ::
+            (MonadIO m, HasCallStack) =>
+              SVGEllipseElement -> m SVGAnimatedLength
+getRxUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getRx (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGEllipseElement.rx Mozilla SVGEllipseElement.rx documentation> 
 getRxUnchecked ::
                (MonadIO m) => SVGEllipseElement -> m SVGAnimatedLength
 getRxUnchecked self
@@ -70,6 +114,15 @@
 getRy ::
       (MonadIO m) => SVGEllipseElement -> m (Maybe SVGAnimatedLength)
 getRy self = liftIO (nullableToMaybe <$> (js_getRy (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGEllipseElement.ry Mozilla SVGEllipseElement.ry documentation> 
+getRyUnsafe ::
+            (MonadIO m, HasCallStack) =>
+              SVGEllipseElement -> m SVGAnimatedLength
+getRyUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getRy (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGEllipseElement.ry Mozilla SVGEllipseElement.ry documentation> 
 getRyUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/SVGExternalResourcesRequired.hs b/src/GHCJS/DOM/JSFFI/Generated/SVGExternalResourcesRequired.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/SVGExternalResourcesRequired.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/SVGExternalResourcesRequired.hs
@@ -1,11 +1,18 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.SVGExternalResourcesRequired
        (js_getExternalResourcesRequired, getExternalResourcesRequired,
+        getExternalResourcesRequiredUnsafe,
         getExternalResourcesRequiredUnchecked,
-        SVGExternalResourcesRequired, castToSVGExternalResourcesRequired,
+        SVGExternalResourcesRequired(..),
         gTypeSVGExternalResourcesRequired)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -21,6 +28,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe
         "$1[\"externalResourcesRequired\"]" js_getExternalResourcesRequired
@@ -33,6 +50,15 @@
 getExternalResourcesRequired self
   = liftIO
       (nullableToMaybe <$> (js_getExternalResourcesRequired (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGExternalResourcesRequired.externalResourcesRequired Mozilla SVGExternalResourcesRequired.externalResourcesRequired documentation> 
+getExternalResourcesRequiredUnsafe ::
+                                   (MonadIO m, HasCallStack) =>
+                                     SVGExternalResourcesRequired -> m SVGAnimatedBoolean
+getExternalResourcesRequiredUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getExternalResourcesRequired (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGExternalResourcesRequired.externalResourcesRequired Mozilla SVGExternalResourcesRequired.externalResourcesRequired documentation> 
 getExternalResourcesRequiredUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/SVGFEBlendElement.hs b/src/GHCJS/DOM/JSFFI/Generated/SVGFEBlendElement.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/SVGFEBlendElement.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/SVGFEBlendElement.hs
@@ -1,13 +1,20 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.SVGFEBlendElement
        (pattern SVG_FEBLEND_MODE_UNKNOWN, pattern SVG_FEBLEND_MODE_NORMAL,
         pattern SVG_FEBLEND_MODE_MULTIPLY, pattern SVG_FEBLEND_MODE_SCREEN,
         pattern SVG_FEBLEND_MODE_DARKEN, pattern SVG_FEBLEND_MODE_LIGHTEN,
-        js_getIn1, getIn1, getIn1Unchecked, js_getIn2, getIn2,
-        getIn2Unchecked, js_getMode, getMode, getModeUnchecked,
-        SVGFEBlendElement, castToSVGFEBlendElement, gTypeSVGFEBlendElement)
+        js_getIn1, getIn1, getIn1Unsafe, getIn1Unchecked, js_getIn2,
+        getIn2, getIn2Unsafe, getIn2Unchecked, js_getMode, getMode,
+        getModeUnsafe, getModeUnchecked, SVGFEBlendElement(..),
+        gTypeSVGFEBlendElement)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -23,6 +30,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
 pattern SVG_FEBLEND_MODE_UNKNOWN = 0
 pattern SVG_FEBLEND_MODE_NORMAL = 1
 pattern SVG_FEBLEND_MODE_MULTIPLY = 2
@@ -39,6 +56,15 @@
 getIn1 self = liftIO (nullableToMaybe <$> (js_getIn1 (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFEBlendElement.in1 Mozilla SVGFEBlendElement.in1 documentation> 
+getIn1Unsafe ::
+             (MonadIO m, HasCallStack) =>
+               SVGFEBlendElement -> m SVGAnimatedString
+getIn1Unsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getIn1 (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFEBlendElement.in1 Mozilla SVGFEBlendElement.in1 documentation> 
 getIn1Unchecked ::
                 (MonadIO m) => SVGFEBlendElement -> m SVGAnimatedString
 getIn1Unchecked self
@@ -53,6 +79,15 @@
 getIn2 self = liftIO (nullableToMaybe <$> (js_getIn2 (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFEBlendElement.in2 Mozilla SVGFEBlendElement.in2 documentation> 
+getIn2Unsafe ::
+             (MonadIO m, HasCallStack) =>
+               SVGFEBlendElement -> m SVGAnimatedString
+getIn2Unsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getIn2 (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFEBlendElement.in2 Mozilla SVGFEBlendElement.in2 documentation> 
 getIn2Unchecked ::
                 (MonadIO m) => SVGFEBlendElement -> m SVGAnimatedString
 getIn2Unchecked self
@@ -66,6 +101,15 @@
         (MonadIO m) =>
           SVGFEBlendElement -> m (Maybe SVGAnimatedEnumeration)
 getMode self = liftIO (nullableToMaybe <$> (js_getMode (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFEBlendElement.mode Mozilla SVGFEBlendElement.mode documentation> 
+getModeUnsafe ::
+              (MonadIO m, HasCallStack) =>
+                SVGFEBlendElement -> m SVGAnimatedEnumeration
+getModeUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getMode (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFEBlendElement.mode Mozilla SVGFEBlendElement.mode documentation> 
 getModeUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/SVGFEColorMatrixElement.hs b/src/GHCJS/DOM/JSFFI/Generated/SVGFEColorMatrixElement.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/SVGFEColorMatrixElement.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/SVGFEColorMatrixElement.hs
@@ -1,16 +1,22 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.SVGFEColorMatrixElement
        (pattern SVG_FECOLORMATRIX_TYPE_UNKNOWN,
         pattern SVG_FECOLORMATRIX_TYPE_MATRIX,
         pattern SVG_FECOLORMATRIX_TYPE_SATURATE,
         pattern SVG_FECOLORMATRIX_TYPE_HUEROTATE,
         pattern SVG_FECOLORMATRIX_TYPE_LUMINANCETOALPHA, js_getIn1, getIn1,
-        getIn1Unchecked, js_getType, getType, getTypeUnchecked,
-        js_getValues, getValues, getValuesUnchecked,
-        SVGFEColorMatrixElement, castToSVGFEColorMatrixElement,
+        getIn1Unsafe, getIn1Unchecked, js_getType, getType, getTypeUnsafe,
+        getTypeUnchecked, js_getValues, getValues, getValuesUnsafe,
+        getValuesUnchecked, SVGFEColorMatrixElement(..),
         gTypeSVGFEColorMatrixElement)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -26,6 +32,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
 pattern SVG_FECOLORMATRIX_TYPE_UNKNOWN = 0
 pattern SVG_FECOLORMATRIX_TYPE_MATRIX = 1
 pattern SVG_FECOLORMATRIX_TYPE_SATURATE = 2
@@ -42,6 +58,15 @@
 getIn1 self = liftIO (nullableToMaybe <$> (js_getIn1 (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFEColorMatrixElement.in1 Mozilla SVGFEColorMatrixElement.in1 documentation> 
+getIn1Unsafe ::
+             (MonadIO m, HasCallStack) =>
+               SVGFEColorMatrixElement -> m SVGAnimatedString
+getIn1Unsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getIn1 (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFEColorMatrixElement.in1 Mozilla SVGFEColorMatrixElement.in1 documentation> 
 getIn1Unchecked ::
                 (MonadIO m) => SVGFEColorMatrixElement -> m SVGAnimatedString
 getIn1Unchecked self
@@ -57,6 +82,15 @@
 getType self = liftIO (nullableToMaybe <$> (js_getType (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFEColorMatrixElement.type Mozilla SVGFEColorMatrixElement.type documentation> 
+getTypeUnsafe ::
+              (MonadIO m, HasCallStack) =>
+                SVGFEColorMatrixElement -> m SVGAnimatedEnumeration
+getTypeUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getType (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFEColorMatrixElement.type Mozilla SVGFEColorMatrixElement.type documentation> 
 getTypeUnchecked ::
                  (MonadIO m) => SVGFEColorMatrixElement -> m SVGAnimatedEnumeration
 getTypeUnchecked self
@@ -70,6 +104,15 @@
           (MonadIO m) =>
             SVGFEColorMatrixElement -> m (Maybe SVGAnimatedNumberList)
 getValues self = liftIO (nullableToMaybe <$> (js_getValues (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFEColorMatrixElement.values Mozilla SVGFEColorMatrixElement.values documentation> 
+getValuesUnsafe ::
+                (MonadIO m, HasCallStack) =>
+                  SVGFEColorMatrixElement -> m SVGAnimatedNumberList
+getValuesUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getValues (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFEColorMatrixElement.values Mozilla SVGFEColorMatrixElement.values documentation> 
 getValuesUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/SVGFEComponentTransferElement.hs b/src/GHCJS/DOM/JSFFI/Generated/SVGFEComponentTransferElement.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/SVGFEComponentTransferElement.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/SVGFEComponentTransferElement.hs
@@ -1,10 +1,16 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.SVGFEComponentTransferElement
-       (js_getIn1, getIn1, getIn1Unchecked, SVGFEComponentTransferElement,
-        castToSVGFEComponentTransferElement,
+       (js_getIn1, getIn1, getIn1Unsafe, getIn1Unchecked,
+        SVGFEComponentTransferElement(..),
         gTypeSVGFEComponentTransferElement)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -20,6 +26,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"in1\"]" js_getIn1 ::
         SVGFEComponentTransferElement -> IO (Nullable SVGAnimatedString)
@@ -29,6 +45,15 @@
        (MonadIO m) =>
          SVGFEComponentTransferElement -> m (Maybe SVGAnimatedString)
 getIn1 self = liftIO (nullableToMaybe <$> (js_getIn1 (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFEComponentTransferElement.in1 Mozilla SVGFEComponentTransferElement.in1 documentation> 
+getIn1Unsafe ::
+             (MonadIO m, HasCallStack) =>
+               SVGFEComponentTransferElement -> m SVGAnimatedString
+getIn1Unsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getIn1 (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFEComponentTransferElement.in1 Mozilla SVGFEComponentTransferElement.in1 documentation> 
 getIn1Unchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/SVGFECompositeElement.hs b/src/GHCJS/DOM/JSFFI/Generated/SVGFECompositeElement.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/SVGFECompositeElement.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/SVGFECompositeElement.hs
@@ -1,4 +1,9 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.SVGFECompositeElement
        (pattern SVG_FECOMPOSITE_OPERATOR_UNKNOWN,
         pattern SVG_FECOMPOSITE_OPERATOR_OVER,
@@ -7,14 +12,16 @@
         pattern SVG_FECOMPOSITE_OPERATOR_ATOP,
         pattern SVG_FECOMPOSITE_OPERATOR_XOR,
         pattern SVG_FECOMPOSITE_OPERATOR_ARITHMETIC, js_getIn1, getIn1,
-        getIn1Unchecked, js_getIn2, getIn2, getIn2Unchecked,
-        js_getOperator, getOperator, getOperatorUnchecked, js_getK1, getK1,
-        getK1Unchecked, js_getK2, getK2, getK2Unchecked, js_getK3, getK3,
-        getK3Unchecked, js_getK4, getK4, getK4Unchecked,
-        SVGFECompositeElement, castToSVGFECompositeElement,
+        getIn1Unsafe, getIn1Unchecked, js_getIn2, getIn2, getIn2Unsafe,
+        getIn2Unchecked, js_getOperator, getOperator, getOperatorUnsafe,
+        getOperatorUnchecked, js_getK1, getK1, getK1Unsafe, getK1Unchecked,
+        js_getK2, getK2, getK2Unsafe, getK2Unchecked, js_getK3, getK3,
+        getK3Unsafe, getK3Unchecked, js_getK4, getK4, getK4Unsafe,
+        getK4Unchecked, SVGFECompositeElement(..),
         gTypeSVGFECompositeElement)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -30,6 +37,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
 pattern SVG_FECOMPOSITE_OPERATOR_UNKNOWN = 0
 pattern SVG_FECOMPOSITE_OPERATOR_OVER = 1
 pattern SVG_FECOMPOSITE_OPERATOR_IN = 2
@@ -47,6 +64,15 @@
 getIn1 self = liftIO (nullableToMaybe <$> (js_getIn1 (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFECompositeElement.in1 Mozilla SVGFECompositeElement.in1 documentation> 
+getIn1Unsafe ::
+             (MonadIO m, HasCallStack) =>
+               SVGFECompositeElement -> m SVGAnimatedString
+getIn1Unsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getIn1 (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFECompositeElement.in1 Mozilla SVGFECompositeElement.in1 documentation> 
 getIn1Unchecked ::
                 (MonadIO m) => SVGFECompositeElement -> m SVGAnimatedString
 getIn1Unchecked self
@@ -61,6 +87,15 @@
 getIn2 self = liftIO (nullableToMaybe <$> (js_getIn2 (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFECompositeElement.in2 Mozilla SVGFECompositeElement.in2 documentation> 
+getIn2Unsafe ::
+             (MonadIO m, HasCallStack) =>
+               SVGFECompositeElement -> m SVGAnimatedString
+getIn2Unsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getIn2 (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFECompositeElement.in2 Mozilla SVGFECompositeElement.in2 documentation> 
 getIn2Unchecked ::
                 (MonadIO m) => SVGFECompositeElement -> m SVGAnimatedString
 getIn2Unchecked self
@@ -77,6 +112,15 @@
   = liftIO (nullableToMaybe <$> (js_getOperator (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFECompositeElement.operator Mozilla SVGFECompositeElement.operator documentation> 
+getOperatorUnsafe ::
+                  (MonadIO m, HasCallStack) =>
+                    SVGFECompositeElement -> m SVGAnimatedEnumeration
+getOperatorUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getOperator (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFECompositeElement.operator Mozilla SVGFECompositeElement.operator documentation> 
 getOperatorUnchecked ::
                      (MonadIO m) => SVGFECompositeElement -> m SVGAnimatedEnumeration
 getOperatorUnchecked self
@@ -91,6 +135,15 @@
 getK1 self = liftIO (nullableToMaybe <$> (js_getK1 (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFECompositeElement.k1 Mozilla SVGFECompositeElement.k1 documentation> 
+getK1Unsafe ::
+            (MonadIO m, HasCallStack) =>
+              SVGFECompositeElement -> m SVGAnimatedNumber
+getK1Unsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getK1 (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFECompositeElement.k1 Mozilla SVGFECompositeElement.k1 documentation> 
 getK1Unchecked ::
                (MonadIO m) => SVGFECompositeElement -> m SVGAnimatedNumber
 getK1Unchecked self
@@ -105,6 +158,15 @@
 getK2 self = liftIO (nullableToMaybe <$> (js_getK2 (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFECompositeElement.k2 Mozilla SVGFECompositeElement.k2 documentation> 
+getK2Unsafe ::
+            (MonadIO m, HasCallStack) =>
+              SVGFECompositeElement -> m SVGAnimatedNumber
+getK2Unsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getK2 (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFECompositeElement.k2 Mozilla SVGFECompositeElement.k2 documentation> 
 getK2Unchecked ::
                (MonadIO m) => SVGFECompositeElement -> m SVGAnimatedNumber
 getK2Unchecked self
@@ -119,6 +181,15 @@
 getK3 self = liftIO (nullableToMaybe <$> (js_getK3 (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFECompositeElement.k3 Mozilla SVGFECompositeElement.k3 documentation> 
+getK3Unsafe ::
+            (MonadIO m, HasCallStack) =>
+              SVGFECompositeElement -> m SVGAnimatedNumber
+getK3Unsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getK3 (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFECompositeElement.k3 Mozilla SVGFECompositeElement.k3 documentation> 
 getK3Unchecked ::
                (MonadIO m) => SVGFECompositeElement -> m SVGAnimatedNumber
 getK3Unchecked self
@@ -131,6 +202,15 @@
 getK4 ::
       (MonadIO m) => SVGFECompositeElement -> m (Maybe SVGAnimatedNumber)
 getK4 self = liftIO (nullableToMaybe <$> (js_getK4 (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFECompositeElement.k4 Mozilla SVGFECompositeElement.k4 documentation> 
+getK4Unsafe ::
+            (MonadIO m, HasCallStack) =>
+              SVGFECompositeElement -> m SVGAnimatedNumber
+getK4Unsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getK4 (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFECompositeElement.k4 Mozilla SVGFECompositeElement.k4 documentation> 
 getK4Unchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/SVGFEConvolveMatrixElement.hs b/src/GHCJS/DOM/JSFFI/Generated/SVGFEConvolveMatrixElement.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/SVGFEConvolveMatrixElement.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/SVGFEConvolveMatrixElement.hs
@@ -1,23 +1,32 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.SVGFEConvolveMatrixElement
        (pattern SVG_EDGEMODE_UNKNOWN, pattern SVG_EDGEMODE_DUPLICATE,
         pattern SVG_EDGEMODE_WRAP, pattern SVG_EDGEMODE_NONE, js_getIn1,
-        getIn1, getIn1Unchecked, js_getOrderX, getOrderX,
-        getOrderXUnchecked, js_getOrderY, getOrderY, getOrderYUnchecked,
-        js_getKernelMatrix, getKernelMatrix, getKernelMatrixUnchecked,
-        js_getDivisor, getDivisor, getDivisorUnchecked, js_getBias,
-        getBias, getBiasUnchecked, js_getTargetX, getTargetX,
-        getTargetXUnchecked, js_getTargetY, getTargetY,
-        getTargetYUnchecked, js_getEdgeMode, getEdgeMode,
+        getIn1, getIn1Unsafe, getIn1Unchecked, js_getOrderX, getOrderX,
+        getOrderXUnsafe, getOrderXUnchecked, js_getOrderY, getOrderY,
+        getOrderYUnsafe, getOrderYUnchecked, js_getKernelMatrix,
+        getKernelMatrix, getKernelMatrixUnsafe, getKernelMatrixUnchecked,
+        js_getDivisor, getDivisor, getDivisorUnsafe, getDivisorUnchecked,
+        js_getBias, getBias, getBiasUnsafe, getBiasUnchecked,
+        js_getTargetX, getTargetX, getTargetXUnsafe, getTargetXUnchecked,
+        js_getTargetY, getTargetY, getTargetYUnsafe, getTargetYUnchecked,
+        js_getEdgeMode, getEdgeMode, getEdgeModeUnsafe,
         getEdgeModeUnchecked, js_getKernelUnitLengthX,
-        getKernelUnitLengthX, getKernelUnitLengthXUnchecked,
-        js_getKernelUnitLengthY, getKernelUnitLengthY,
+        getKernelUnitLengthX, getKernelUnitLengthXUnsafe,
+        getKernelUnitLengthXUnchecked, js_getKernelUnitLengthY,
+        getKernelUnitLengthY, getKernelUnitLengthYUnsafe,
         getKernelUnitLengthYUnchecked, js_getPreserveAlpha,
-        getPreserveAlpha, getPreserveAlphaUnchecked,
-        SVGFEConvolveMatrixElement, castToSVGFEConvolveMatrixElement,
+        getPreserveAlpha, getPreserveAlphaUnsafe,
+        getPreserveAlphaUnchecked, SVGFEConvolveMatrixElement(..),
         gTypeSVGFEConvolveMatrixElement)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -33,6 +42,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
 pattern SVG_EDGEMODE_UNKNOWN = 0
 pattern SVG_EDGEMODE_DUPLICATE = 1
 pattern SVG_EDGEMODE_WRAP = 2
@@ -48,6 +67,15 @@
 getIn1 self = liftIO (nullableToMaybe <$> (js_getIn1 (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFEConvolveMatrixElement.in1 Mozilla SVGFEConvolveMatrixElement.in1 documentation> 
+getIn1Unsafe ::
+             (MonadIO m, HasCallStack) =>
+               SVGFEConvolveMatrixElement -> m SVGAnimatedString
+getIn1Unsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getIn1 (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFEConvolveMatrixElement.in1 Mozilla SVGFEConvolveMatrixElement.in1 documentation> 
 getIn1Unchecked ::
                 (MonadIO m) => SVGFEConvolveMatrixElement -> m SVGAnimatedString
 getIn1Unchecked self
@@ -63,6 +91,15 @@
 getOrderX self = liftIO (nullableToMaybe <$> (js_getOrderX (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFEConvolveMatrixElement.orderX Mozilla SVGFEConvolveMatrixElement.orderX documentation> 
+getOrderXUnsafe ::
+                (MonadIO m, HasCallStack) =>
+                  SVGFEConvolveMatrixElement -> m SVGAnimatedInteger
+getOrderXUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getOrderX (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFEConvolveMatrixElement.orderX Mozilla SVGFEConvolveMatrixElement.orderX documentation> 
 getOrderXUnchecked ::
                    (MonadIO m) => SVGFEConvolveMatrixElement -> m SVGAnimatedInteger
 getOrderXUnchecked self
@@ -78,6 +115,15 @@
 getOrderY self = liftIO (nullableToMaybe <$> (js_getOrderY (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFEConvolveMatrixElement.orderY Mozilla SVGFEConvolveMatrixElement.orderY documentation> 
+getOrderYUnsafe ::
+                (MonadIO m, HasCallStack) =>
+                  SVGFEConvolveMatrixElement -> m SVGAnimatedInteger
+getOrderYUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getOrderY (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFEConvolveMatrixElement.orderY Mozilla SVGFEConvolveMatrixElement.orderY documentation> 
 getOrderYUnchecked ::
                    (MonadIO m) => SVGFEConvolveMatrixElement -> m SVGAnimatedInteger
 getOrderYUnchecked self
@@ -95,6 +141,15 @@
   = liftIO (nullableToMaybe <$> (js_getKernelMatrix (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFEConvolveMatrixElement.kernelMatrix Mozilla SVGFEConvolveMatrixElement.kernelMatrix documentation> 
+getKernelMatrixUnsafe ::
+                      (MonadIO m, HasCallStack) =>
+                        SVGFEConvolveMatrixElement -> m SVGAnimatedNumberList
+getKernelMatrixUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getKernelMatrix (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFEConvolveMatrixElement.kernelMatrix Mozilla SVGFEConvolveMatrixElement.kernelMatrix documentation> 
 getKernelMatrixUnchecked ::
                          (MonadIO m) =>
                            SVGFEConvolveMatrixElement -> m SVGAnimatedNumberList
@@ -113,6 +168,15 @@
   = liftIO (nullableToMaybe <$> (js_getDivisor (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFEConvolveMatrixElement.divisor Mozilla SVGFEConvolveMatrixElement.divisor documentation> 
+getDivisorUnsafe ::
+                 (MonadIO m, HasCallStack) =>
+                   SVGFEConvolveMatrixElement -> m SVGAnimatedNumber
+getDivisorUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getDivisor (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFEConvolveMatrixElement.divisor Mozilla SVGFEConvolveMatrixElement.divisor documentation> 
 getDivisorUnchecked ::
                     (MonadIO m) => SVGFEConvolveMatrixElement -> m SVGAnimatedNumber
 getDivisorUnchecked self
@@ -128,6 +192,15 @@
 getBias self = liftIO (nullableToMaybe <$> (js_getBias (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFEConvolveMatrixElement.bias Mozilla SVGFEConvolveMatrixElement.bias documentation> 
+getBiasUnsafe ::
+              (MonadIO m, HasCallStack) =>
+                SVGFEConvolveMatrixElement -> m SVGAnimatedNumber
+getBiasUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getBias (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFEConvolveMatrixElement.bias Mozilla SVGFEConvolveMatrixElement.bias documentation> 
 getBiasUnchecked ::
                  (MonadIO m) => SVGFEConvolveMatrixElement -> m SVGAnimatedNumber
 getBiasUnchecked self
@@ -144,6 +217,15 @@
   = liftIO (nullableToMaybe <$> (js_getTargetX (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFEConvolveMatrixElement.targetX Mozilla SVGFEConvolveMatrixElement.targetX documentation> 
+getTargetXUnsafe ::
+                 (MonadIO m, HasCallStack) =>
+                   SVGFEConvolveMatrixElement -> m SVGAnimatedInteger
+getTargetXUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getTargetX (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFEConvolveMatrixElement.targetX Mozilla SVGFEConvolveMatrixElement.targetX documentation> 
 getTargetXUnchecked ::
                     (MonadIO m) => SVGFEConvolveMatrixElement -> m SVGAnimatedInteger
 getTargetXUnchecked self
@@ -160,6 +242,15 @@
   = liftIO (nullableToMaybe <$> (js_getTargetY (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFEConvolveMatrixElement.targetY Mozilla SVGFEConvolveMatrixElement.targetY documentation> 
+getTargetYUnsafe ::
+                 (MonadIO m, HasCallStack) =>
+                   SVGFEConvolveMatrixElement -> m SVGAnimatedInteger
+getTargetYUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getTargetY (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFEConvolveMatrixElement.targetY Mozilla SVGFEConvolveMatrixElement.targetY documentation> 
 getTargetYUnchecked ::
                     (MonadIO m) => SVGFEConvolveMatrixElement -> m SVGAnimatedInteger
 getTargetYUnchecked self
@@ -177,6 +268,15 @@
   = liftIO (nullableToMaybe <$> (js_getEdgeMode (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFEConvolveMatrixElement.edgeMode Mozilla SVGFEConvolveMatrixElement.edgeMode documentation> 
+getEdgeModeUnsafe ::
+                  (MonadIO m, HasCallStack) =>
+                    SVGFEConvolveMatrixElement -> m SVGAnimatedEnumeration
+getEdgeModeUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getEdgeMode (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFEConvolveMatrixElement.edgeMode Mozilla SVGFEConvolveMatrixElement.edgeMode documentation> 
 getEdgeModeUnchecked ::
                      (MonadIO m) =>
                        SVGFEConvolveMatrixElement -> m SVGAnimatedEnumeration
@@ -195,6 +295,15 @@
   = liftIO (nullableToMaybe <$> (js_getKernelUnitLengthX (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFEConvolveMatrixElement.kernelUnitLengthX Mozilla SVGFEConvolveMatrixElement.kernelUnitLengthX documentation> 
+getKernelUnitLengthXUnsafe ::
+                           (MonadIO m, HasCallStack) =>
+                             SVGFEConvolveMatrixElement -> m SVGAnimatedNumber
+getKernelUnitLengthXUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getKernelUnitLengthX (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFEConvolveMatrixElement.kernelUnitLengthX Mozilla SVGFEConvolveMatrixElement.kernelUnitLengthX documentation> 
 getKernelUnitLengthXUnchecked ::
                               (MonadIO m) => SVGFEConvolveMatrixElement -> m SVGAnimatedNumber
 getKernelUnitLengthXUnchecked self
@@ -213,6 +322,15 @@
   = liftIO (nullableToMaybe <$> (js_getKernelUnitLengthY (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFEConvolveMatrixElement.kernelUnitLengthY Mozilla SVGFEConvolveMatrixElement.kernelUnitLengthY documentation> 
+getKernelUnitLengthYUnsafe ::
+                           (MonadIO m, HasCallStack) =>
+                             SVGFEConvolveMatrixElement -> m SVGAnimatedNumber
+getKernelUnitLengthYUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getKernelUnitLengthY (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFEConvolveMatrixElement.kernelUnitLengthY Mozilla SVGFEConvolveMatrixElement.kernelUnitLengthY documentation> 
 getKernelUnitLengthYUnchecked ::
                               (MonadIO m) => SVGFEConvolveMatrixElement -> m SVGAnimatedNumber
 getKernelUnitLengthYUnchecked self
@@ -229,6 +347,15 @@
                    SVGFEConvolveMatrixElement -> m (Maybe SVGAnimatedBoolean)
 getPreserveAlpha self
   = liftIO (nullableToMaybe <$> (js_getPreserveAlpha (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFEConvolveMatrixElement.preserveAlpha Mozilla SVGFEConvolveMatrixElement.preserveAlpha documentation> 
+getPreserveAlphaUnsafe ::
+                       (MonadIO m, HasCallStack) =>
+                         SVGFEConvolveMatrixElement -> m SVGAnimatedBoolean
+getPreserveAlphaUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getPreserveAlpha (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFEConvolveMatrixElement.preserveAlpha Mozilla SVGFEConvolveMatrixElement.preserveAlpha documentation> 
 getPreserveAlphaUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/SVGFEDiffuseLightingElement.hs b/src/GHCJS/DOM/JSFFI/Generated/SVGFEDiffuseLightingElement.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/SVGFEDiffuseLightingElement.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/SVGFEDiffuseLightingElement.hs
@@ -1,15 +1,23 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.SVGFEDiffuseLightingElement
-       (js_getIn1, getIn1, getIn1Unchecked, js_getSurfaceScale,
-        getSurfaceScale, getSurfaceScaleUnchecked, js_getDiffuseConstant,
-        getDiffuseConstant, getDiffuseConstantUnchecked,
-        js_getKernelUnitLengthX, getKernelUnitLengthX,
+       (js_getIn1, getIn1, getIn1Unsafe, getIn1Unchecked,
+        js_getSurfaceScale, getSurfaceScale, getSurfaceScaleUnsafe,
+        getSurfaceScaleUnchecked, js_getDiffuseConstant,
+        getDiffuseConstant, getDiffuseConstantUnsafe,
+        getDiffuseConstantUnchecked, js_getKernelUnitLengthX,
+        getKernelUnitLengthX, getKernelUnitLengthXUnsafe,
         getKernelUnitLengthXUnchecked, js_getKernelUnitLengthY,
-        getKernelUnitLengthY, getKernelUnitLengthYUnchecked,
-        SVGFEDiffuseLightingElement, castToSVGFEDiffuseLightingElement,
+        getKernelUnitLengthY, getKernelUnitLengthYUnsafe,
+        getKernelUnitLengthYUnchecked, SVGFEDiffuseLightingElement(..),
         gTypeSVGFEDiffuseLightingElement)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -25,6 +33,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"in1\"]" js_getIn1 ::
         SVGFEDiffuseLightingElement -> IO (Nullable SVGAnimatedString)
@@ -36,6 +54,15 @@
 getIn1 self = liftIO (nullableToMaybe <$> (js_getIn1 (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFEDiffuseLightingElement.in1 Mozilla SVGFEDiffuseLightingElement.in1 documentation> 
+getIn1Unsafe ::
+             (MonadIO m, HasCallStack) =>
+               SVGFEDiffuseLightingElement -> m SVGAnimatedString
+getIn1Unsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getIn1 (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFEDiffuseLightingElement.in1 Mozilla SVGFEDiffuseLightingElement.in1 documentation> 
 getIn1Unchecked ::
                 (MonadIO m) => SVGFEDiffuseLightingElement -> m SVGAnimatedString
 getIn1Unchecked self
@@ -53,6 +80,15 @@
   = liftIO (nullableToMaybe <$> (js_getSurfaceScale (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFEDiffuseLightingElement.surfaceScale Mozilla SVGFEDiffuseLightingElement.surfaceScale documentation> 
+getSurfaceScaleUnsafe ::
+                      (MonadIO m, HasCallStack) =>
+                        SVGFEDiffuseLightingElement -> m SVGAnimatedNumber
+getSurfaceScaleUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getSurfaceScale (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFEDiffuseLightingElement.surfaceScale Mozilla SVGFEDiffuseLightingElement.surfaceScale documentation> 
 getSurfaceScaleUnchecked ::
                          (MonadIO m) => SVGFEDiffuseLightingElement -> m SVGAnimatedNumber
 getSurfaceScaleUnchecked self
@@ -71,6 +107,15 @@
   = liftIO (nullableToMaybe <$> (js_getDiffuseConstant (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFEDiffuseLightingElement.diffuseConstant Mozilla SVGFEDiffuseLightingElement.diffuseConstant documentation> 
+getDiffuseConstantUnsafe ::
+                         (MonadIO m, HasCallStack) =>
+                           SVGFEDiffuseLightingElement -> m SVGAnimatedNumber
+getDiffuseConstantUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getDiffuseConstant (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFEDiffuseLightingElement.diffuseConstant Mozilla SVGFEDiffuseLightingElement.diffuseConstant documentation> 
 getDiffuseConstantUnchecked ::
                             (MonadIO m) => SVGFEDiffuseLightingElement -> m SVGAnimatedNumber
 getDiffuseConstantUnchecked self
@@ -89,6 +134,15 @@
   = liftIO (nullableToMaybe <$> (js_getKernelUnitLengthX (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFEDiffuseLightingElement.kernelUnitLengthX Mozilla SVGFEDiffuseLightingElement.kernelUnitLengthX documentation> 
+getKernelUnitLengthXUnsafe ::
+                           (MonadIO m, HasCallStack) =>
+                             SVGFEDiffuseLightingElement -> m SVGAnimatedNumber
+getKernelUnitLengthXUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getKernelUnitLengthX (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFEDiffuseLightingElement.kernelUnitLengthX Mozilla SVGFEDiffuseLightingElement.kernelUnitLengthX documentation> 
 getKernelUnitLengthXUnchecked ::
                               (MonadIO m) => SVGFEDiffuseLightingElement -> m SVGAnimatedNumber
 getKernelUnitLengthXUnchecked self
@@ -105,6 +159,15 @@
                        SVGFEDiffuseLightingElement -> m (Maybe SVGAnimatedNumber)
 getKernelUnitLengthY self
   = liftIO (nullableToMaybe <$> (js_getKernelUnitLengthY (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFEDiffuseLightingElement.kernelUnitLengthY Mozilla SVGFEDiffuseLightingElement.kernelUnitLengthY documentation> 
+getKernelUnitLengthYUnsafe ::
+                           (MonadIO m, HasCallStack) =>
+                             SVGFEDiffuseLightingElement -> m SVGAnimatedNumber
+getKernelUnitLengthYUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getKernelUnitLengthY (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFEDiffuseLightingElement.kernelUnitLengthY Mozilla SVGFEDiffuseLightingElement.kernelUnitLengthY documentation> 
 getKernelUnitLengthYUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/SVGFEDisplacementMapElement.hs b/src/GHCJS/DOM/JSFFI/Generated/SVGFEDisplacementMapElement.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/SVGFEDisplacementMapElement.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/SVGFEDisplacementMapElement.hs
@@ -1,16 +1,23 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.SVGFEDisplacementMapElement
        (pattern SVG_CHANNEL_UNKNOWN, pattern SVG_CHANNEL_R,
         pattern SVG_CHANNEL_G, pattern SVG_CHANNEL_B,
-        pattern SVG_CHANNEL_A, js_getIn1, getIn1, getIn1Unchecked,
-        js_getIn2, getIn2, getIn2Unchecked, js_getScale, getScale,
-        getScaleUnchecked, js_getXChannelSelector, getXChannelSelector,
-        getXChannelSelectorUnchecked, js_getYChannelSelector,
-        getYChannelSelector, getYChannelSelectorUnchecked,
-        SVGFEDisplacementMapElement, castToSVGFEDisplacementMapElement,
-        gTypeSVGFEDisplacementMapElement)
+        pattern SVG_CHANNEL_A, js_getIn1, getIn1, getIn1Unsafe,
+        getIn1Unchecked, js_getIn2, getIn2, getIn2Unsafe, getIn2Unchecked,
+        js_getScale, getScale, getScaleUnsafe, getScaleUnchecked,
+        js_getXChannelSelector, getXChannelSelector,
+        getXChannelSelectorUnsafe, getXChannelSelectorUnchecked,
+        js_getYChannelSelector, getYChannelSelector,
+        getYChannelSelectorUnsafe, getYChannelSelectorUnchecked,
+        SVGFEDisplacementMapElement(..), gTypeSVGFEDisplacementMapElement)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -26,6 +33,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
 pattern SVG_CHANNEL_UNKNOWN = 0
 pattern SVG_CHANNEL_R = 1
 pattern SVG_CHANNEL_G = 2
@@ -42,6 +59,15 @@
 getIn1 self = liftIO (nullableToMaybe <$> (js_getIn1 (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFEDisplacementMapElement.in1 Mozilla SVGFEDisplacementMapElement.in1 documentation> 
+getIn1Unsafe ::
+             (MonadIO m, HasCallStack) =>
+               SVGFEDisplacementMapElement -> m SVGAnimatedString
+getIn1Unsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getIn1 (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFEDisplacementMapElement.in1 Mozilla SVGFEDisplacementMapElement.in1 documentation> 
 getIn1Unchecked ::
                 (MonadIO m) => SVGFEDisplacementMapElement -> m SVGAnimatedString
 getIn1Unchecked self
@@ -57,6 +83,15 @@
 getIn2 self = liftIO (nullableToMaybe <$> (js_getIn2 (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFEDisplacementMapElement.in2 Mozilla SVGFEDisplacementMapElement.in2 documentation> 
+getIn2Unsafe ::
+             (MonadIO m, HasCallStack) =>
+               SVGFEDisplacementMapElement -> m SVGAnimatedString
+getIn2Unsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getIn2 (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFEDisplacementMapElement.in2 Mozilla SVGFEDisplacementMapElement.in2 documentation> 
 getIn2Unchecked ::
                 (MonadIO m) => SVGFEDisplacementMapElement -> m SVGAnimatedString
 getIn2Unchecked self
@@ -72,6 +107,15 @@
 getScale self = liftIO (nullableToMaybe <$> (js_getScale (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFEDisplacementMapElement.scale Mozilla SVGFEDisplacementMapElement.scale documentation> 
+getScaleUnsafe ::
+               (MonadIO m, HasCallStack) =>
+                 SVGFEDisplacementMapElement -> m SVGAnimatedNumber
+getScaleUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getScale (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFEDisplacementMapElement.scale Mozilla SVGFEDisplacementMapElement.scale documentation> 
 getScaleUnchecked ::
                   (MonadIO m) => SVGFEDisplacementMapElement -> m SVGAnimatedNumber
 getScaleUnchecked self
@@ -89,6 +133,15 @@
   = liftIO (nullableToMaybe <$> (js_getXChannelSelector (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFEDisplacementMapElement.xChannelSelector Mozilla SVGFEDisplacementMapElement.xChannelSelector documentation> 
+getXChannelSelectorUnsafe ::
+                          (MonadIO m, HasCallStack) =>
+                            SVGFEDisplacementMapElement -> m SVGAnimatedEnumeration
+getXChannelSelectorUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getXChannelSelector (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFEDisplacementMapElement.xChannelSelector Mozilla SVGFEDisplacementMapElement.xChannelSelector documentation> 
 getXChannelSelectorUnchecked ::
                              (MonadIO m) =>
                                SVGFEDisplacementMapElement -> m SVGAnimatedEnumeration
@@ -106,6 +159,15 @@
                       SVGFEDisplacementMapElement -> m (Maybe SVGAnimatedEnumeration)
 getYChannelSelector self
   = liftIO (nullableToMaybe <$> (js_getYChannelSelector (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFEDisplacementMapElement.yChannelSelector Mozilla SVGFEDisplacementMapElement.yChannelSelector documentation> 
+getYChannelSelectorUnsafe ::
+                          (MonadIO m, HasCallStack) =>
+                            SVGFEDisplacementMapElement -> m SVGAnimatedEnumeration
+getYChannelSelectorUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getYChannelSelector (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFEDisplacementMapElement.yChannelSelector Mozilla SVGFEDisplacementMapElement.yChannelSelector documentation> 
 getYChannelSelectorUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/SVGFEDistantLightElement.hs b/src/GHCJS/DOM/JSFFI/Generated/SVGFEDistantLightElement.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/SVGFEDistantLightElement.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/SVGFEDistantLightElement.hs
@@ -1,10 +1,17 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.SVGFEDistantLightElement
-       (js_getAzimuth, getAzimuth, getAzimuthUnchecked, js_getElevation,
-        getElevation, getElevationUnchecked, SVGFEDistantLightElement,
-        castToSVGFEDistantLightElement, gTypeSVGFEDistantLightElement)
+       (js_getAzimuth, getAzimuth, getAzimuthUnsafe, getAzimuthUnchecked,
+        js_getElevation, getElevation, getElevationUnsafe,
+        getElevationUnchecked, SVGFEDistantLightElement(..),
+        gTypeSVGFEDistantLightElement)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -20,6 +27,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"azimuth\"]" js_getAzimuth ::
         SVGFEDistantLightElement -> IO (Nullable SVGAnimatedNumber)
@@ -32,6 +49,15 @@
   = liftIO (nullableToMaybe <$> (js_getAzimuth (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFEDistantLightElement.azimuth Mozilla SVGFEDistantLightElement.azimuth documentation> 
+getAzimuthUnsafe ::
+                 (MonadIO m, HasCallStack) =>
+                   SVGFEDistantLightElement -> m SVGAnimatedNumber
+getAzimuthUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getAzimuth (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFEDistantLightElement.azimuth Mozilla SVGFEDistantLightElement.azimuth documentation> 
 getAzimuthUnchecked ::
                     (MonadIO m) => SVGFEDistantLightElement -> m SVGAnimatedNumber
 getAzimuthUnchecked self
@@ -47,6 +73,15 @@
                SVGFEDistantLightElement -> m (Maybe SVGAnimatedNumber)
 getElevation self
   = liftIO (nullableToMaybe <$> (js_getElevation (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFEDistantLightElement.elevation Mozilla SVGFEDistantLightElement.elevation documentation> 
+getElevationUnsafe ::
+                   (MonadIO m, HasCallStack) =>
+                     SVGFEDistantLightElement -> m SVGAnimatedNumber
+getElevationUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getElevation (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFEDistantLightElement.elevation Mozilla SVGFEDistantLightElement.elevation documentation> 
 getElevationUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/SVGFEDropShadowElement.hs b/src/GHCJS/DOM/JSFFI/Generated/SVGFEDropShadowElement.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/SVGFEDropShadowElement.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/SVGFEDropShadowElement.hs
@@ -1,13 +1,20 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.SVGFEDropShadowElement
        (js_setStdDeviation, setStdDeviation, js_getIn1, getIn1,
-        getIn1Unchecked, js_getDx, getDx, getDxUnchecked, js_getDy, getDy,
-        getDyUnchecked, js_getStdDeviationX, getStdDeviationX,
+        getIn1Unsafe, getIn1Unchecked, js_getDx, getDx, getDxUnsafe,
+        getDxUnchecked, js_getDy, getDy, getDyUnsafe, getDyUnchecked,
+        js_getStdDeviationX, getStdDeviationX, getStdDeviationXUnsafe,
         getStdDeviationXUnchecked, js_getStdDeviationY, getStdDeviationY,
-        getStdDeviationYUnchecked, SVGFEDropShadowElement,
-        castToSVGFEDropShadowElement, gTypeSVGFEDropShadowElement)
+        getStdDeviationYUnsafe, getStdDeviationYUnchecked,
+        SVGFEDropShadowElement(..), gTypeSVGFEDropShadowElement)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -23,6 +30,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"setStdDeviation\"]($2, $3)"
         js_setStdDeviation ::
@@ -44,6 +61,15 @@
 getIn1 self = liftIO (nullableToMaybe <$> (js_getIn1 (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFEDropShadowElement.in1 Mozilla SVGFEDropShadowElement.in1 documentation> 
+getIn1Unsafe ::
+             (MonadIO m, HasCallStack) =>
+               SVGFEDropShadowElement -> m SVGAnimatedString
+getIn1Unsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getIn1 (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFEDropShadowElement.in1 Mozilla SVGFEDropShadowElement.in1 documentation> 
 getIn1Unchecked ::
                 (MonadIO m) => SVGFEDropShadowElement -> m SVGAnimatedString
 getIn1Unchecked self
@@ -59,6 +85,15 @@
 getDx self = liftIO (nullableToMaybe <$> (js_getDx (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFEDropShadowElement.dx Mozilla SVGFEDropShadowElement.dx documentation> 
+getDxUnsafe ::
+            (MonadIO m, HasCallStack) =>
+              SVGFEDropShadowElement -> m SVGAnimatedNumber
+getDxUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getDx (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFEDropShadowElement.dx Mozilla SVGFEDropShadowElement.dx documentation> 
 getDxUnchecked ::
                (MonadIO m) => SVGFEDropShadowElement -> m SVGAnimatedNumber
 getDxUnchecked self
@@ -74,6 +109,15 @@
 getDy self = liftIO (nullableToMaybe <$> (js_getDy (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFEDropShadowElement.dy Mozilla SVGFEDropShadowElement.dy documentation> 
+getDyUnsafe ::
+            (MonadIO m, HasCallStack) =>
+              SVGFEDropShadowElement -> m SVGAnimatedNumber
+getDyUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getDy (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFEDropShadowElement.dy Mozilla SVGFEDropShadowElement.dy documentation> 
 getDyUnchecked ::
                (MonadIO m) => SVGFEDropShadowElement -> m SVGAnimatedNumber
 getDyUnchecked self
@@ -91,6 +135,15 @@
   = liftIO (nullableToMaybe <$> (js_getStdDeviationX (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFEDropShadowElement.stdDeviationX Mozilla SVGFEDropShadowElement.stdDeviationX documentation> 
+getStdDeviationXUnsafe ::
+                       (MonadIO m, HasCallStack) =>
+                         SVGFEDropShadowElement -> m SVGAnimatedNumber
+getStdDeviationXUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getStdDeviationX (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFEDropShadowElement.stdDeviationX Mozilla SVGFEDropShadowElement.stdDeviationX documentation> 
 getStdDeviationXUnchecked ::
                           (MonadIO m) => SVGFEDropShadowElement -> m SVGAnimatedNumber
 getStdDeviationXUnchecked self
@@ -107,6 +160,15 @@
                    SVGFEDropShadowElement -> m (Maybe SVGAnimatedNumber)
 getStdDeviationY self
   = liftIO (nullableToMaybe <$> (js_getStdDeviationY (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFEDropShadowElement.stdDeviationY Mozilla SVGFEDropShadowElement.stdDeviationY documentation> 
+getStdDeviationYUnsafe ::
+                       (MonadIO m, HasCallStack) =>
+                         SVGFEDropShadowElement -> m SVGAnimatedNumber
+getStdDeviationYUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getStdDeviationY (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFEDropShadowElement.stdDeviationY Mozilla SVGFEDropShadowElement.stdDeviationY documentation> 
 getStdDeviationYUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/SVGFEGaussianBlurElement.hs b/src/GHCJS/DOM/JSFFI/Generated/SVGFEGaussianBlurElement.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/SVGFEGaussianBlurElement.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/SVGFEGaussianBlurElement.hs
@@ -1,15 +1,22 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.SVGFEGaussianBlurElement
        (js_setStdDeviation, setStdDeviation, pattern SVG_EDGEMODE_UNKNOWN,
         pattern SVG_EDGEMODE_DUPLICATE, pattern SVG_EDGEMODE_WRAP,
-        pattern SVG_EDGEMODE_NONE, js_getIn1, getIn1, getIn1Unchecked,
-        js_getStdDeviationX, getStdDeviationX, getStdDeviationXUnchecked,
-        js_getStdDeviationY, getStdDeviationY, getStdDeviationYUnchecked,
-        js_getEdgeMode, getEdgeMode, getEdgeModeUnchecked,
-        SVGFEGaussianBlurElement, castToSVGFEGaussianBlurElement,
-        gTypeSVGFEGaussianBlurElement)
+        pattern SVG_EDGEMODE_NONE, js_getIn1, getIn1, getIn1Unsafe,
+        getIn1Unchecked, js_getStdDeviationX, getStdDeviationX,
+        getStdDeviationXUnsafe, getStdDeviationXUnchecked,
+        js_getStdDeviationY, getStdDeviationY, getStdDeviationYUnsafe,
+        getStdDeviationYUnchecked, js_getEdgeMode, getEdgeMode,
+        getEdgeModeUnsafe, getEdgeModeUnchecked,
+        SVGFEGaussianBlurElement(..), gTypeSVGFEGaussianBlurElement)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -25,6 +32,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"setStdDeviation\"]($2, $3)"
         js_setStdDeviation ::
@@ -50,6 +67,15 @@
 getIn1 self = liftIO (nullableToMaybe <$> (js_getIn1 (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFEGaussianBlurElement.in1 Mozilla SVGFEGaussianBlurElement.in1 documentation> 
+getIn1Unsafe ::
+             (MonadIO m, HasCallStack) =>
+               SVGFEGaussianBlurElement -> m SVGAnimatedString
+getIn1Unsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getIn1 (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFEGaussianBlurElement.in1 Mozilla SVGFEGaussianBlurElement.in1 documentation> 
 getIn1Unchecked ::
                 (MonadIO m) => SVGFEGaussianBlurElement -> m SVGAnimatedString
 getIn1Unchecked self
@@ -67,6 +93,15 @@
   = liftIO (nullableToMaybe <$> (js_getStdDeviationX (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFEGaussianBlurElement.stdDeviationX Mozilla SVGFEGaussianBlurElement.stdDeviationX documentation> 
+getStdDeviationXUnsafe ::
+                       (MonadIO m, HasCallStack) =>
+                         SVGFEGaussianBlurElement -> m SVGAnimatedNumber
+getStdDeviationXUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getStdDeviationX (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFEGaussianBlurElement.stdDeviationX Mozilla SVGFEGaussianBlurElement.stdDeviationX documentation> 
 getStdDeviationXUnchecked ::
                           (MonadIO m) => SVGFEGaussianBlurElement -> m SVGAnimatedNumber
 getStdDeviationXUnchecked self
@@ -85,6 +120,15 @@
   = liftIO (nullableToMaybe <$> (js_getStdDeviationY (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFEGaussianBlurElement.stdDeviationY Mozilla SVGFEGaussianBlurElement.stdDeviationY documentation> 
+getStdDeviationYUnsafe ::
+                       (MonadIO m, HasCallStack) =>
+                         SVGFEGaussianBlurElement -> m SVGAnimatedNumber
+getStdDeviationYUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getStdDeviationY (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFEGaussianBlurElement.stdDeviationY Mozilla SVGFEGaussianBlurElement.stdDeviationY documentation> 
 getStdDeviationYUnchecked ::
                           (MonadIO m) => SVGFEGaussianBlurElement -> m SVGAnimatedNumber
 getStdDeviationYUnchecked self
@@ -100,6 +144,15 @@
               SVGFEGaussianBlurElement -> m (Maybe SVGAnimatedEnumeration)
 getEdgeMode self
   = liftIO (nullableToMaybe <$> (js_getEdgeMode (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFEGaussianBlurElement.edgeMode Mozilla SVGFEGaussianBlurElement.edgeMode documentation> 
+getEdgeModeUnsafe ::
+                  (MonadIO m, HasCallStack) =>
+                    SVGFEGaussianBlurElement -> m SVGAnimatedEnumeration
+getEdgeModeUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getEdgeMode (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFEGaussianBlurElement.edgeMode Mozilla SVGFEGaussianBlurElement.edgeMode documentation> 
 getEdgeModeUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/SVGFEImageElement.hs b/src/GHCJS/DOM/JSFFI/Generated/SVGFEImageElement.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/SVGFEImageElement.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/SVGFEImageElement.hs
@@ -1,10 +1,16 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.SVGFEImageElement
        (js_getPreserveAspectRatio, getPreserveAspectRatio,
-        getPreserveAspectRatioUnchecked, SVGFEImageElement,
-        castToSVGFEImageElement, gTypeSVGFEImageElement)
+        getPreserveAspectRatioUnsafe, getPreserveAspectRatioUnchecked,
+        SVGFEImageElement(..), gTypeSVGFEImageElement)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -20,6 +26,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"preserveAspectRatio\"]"
         js_getPreserveAspectRatio ::
@@ -31,6 +47,15 @@
                          SVGFEImageElement -> m (Maybe SVGAnimatedPreserveAspectRatio)
 getPreserveAspectRatio self
   = liftIO (nullableToMaybe <$> (js_getPreserveAspectRatio (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFEImageElement.preserveAspectRatio Mozilla SVGFEImageElement.preserveAspectRatio documentation> 
+getPreserveAspectRatioUnsafe ::
+                             (MonadIO m, HasCallStack) =>
+                               SVGFEImageElement -> m SVGAnimatedPreserveAspectRatio
+getPreserveAspectRatioUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getPreserveAspectRatio (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFEImageElement.preserveAspectRatio Mozilla SVGFEImageElement.preserveAspectRatio documentation> 
 getPreserveAspectRatioUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/SVGFEMergeNodeElement.hs b/src/GHCJS/DOM/JSFFI/Generated/SVGFEMergeNodeElement.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/SVGFEMergeNodeElement.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/SVGFEMergeNodeElement.hs
@@ -1,9 +1,15 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.SVGFEMergeNodeElement
-       (js_getIn1, getIn1, getIn1Unchecked, SVGFEMergeNodeElement,
-        castToSVGFEMergeNodeElement, gTypeSVGFEMergeNodeElement)
+       (js_getIn1, getIn1, getIn1Unsafe, getIn1Unchecked,
+        SVGFEMergeNodeElement(..), gTypeSVGFEMergeNodeElement)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -19,6 +25,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"in1\"]" js_getIn1 ::
         SVGFEMergeNodeElement -> IO (Nullable SVGAnimatedString)
@@ -27,6 +43,15 @@
 getIn1 ::
        (MonadIO m) => SVGFEMergeNodeElement -> m (Maybe SVGAnimatedString)
 getIn1 self = liftIO (nullableToMaybe <$> (js_getIn1 (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFEMergeNodeElement.in1 Mozilla SVGFEMergeNodeElement.in1 documentation> 
+getIn1Unsafe ::
+             (MonadIO m, HasCallStack) =>
+               SVGFEMergeNodeElement -> m SVGAnimatedString
+getIn1Unsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getIn1 (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFEMergeNodeElement.in1 Mozilla SVGFEMergeNodeElement.in1 documentation> 
 getIn1Unchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/SVGFEMorphologyElement.hs b/src/GHCJS/DOM/JSFFI/Generated/SVGFEMorphologyElement.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/SVGFEMorphologyElement.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/SVGFEMorphologyElement.hs
@@ -1,14 +1,21 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.SVGFEMorphologyElement
        (js_setRadius, setRadius, pattern SVG_MORPHOLOGY_OPERATOR_UNKNOWN,
         pattern SVG_MORPHOLOGY_OPERATOR_ERODE,
         pattern SVG_MORPHOLOGY_OPERATOR_DILATE, js_getIn1, getIn1,
-        getIn1Unchecked, js_getOperator, getOperator, getOperatorUnchecked,
-        js_getRadiusX, getRadiusX, getRadiusXUnchecked, js_getRadiusY,
-        getRadiusY, getRadiusYUnchecked, SVGFEMorphologyElement,
-        castToSVGFEMorphologyElement, gTypeSVGFEMorphologyElement)
+        getIn1Unsafe, getIn1Unchecked, js_getOperator, getOperator,
+        getOperatorUnsafe, getOperatorUnchecked, js_getRadiusX, getRadiusX,
+        getRadiusXUnsafe, getRadiusXUnchecked, js_getRadiusY, getRadiusY,
+        getRadiusYUnsafe, getRadiusYUnchecked, SVGFEMorphologyElement(..),
+        gTypeSVGFEMorphologyElement)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -24,6 +31,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"setRadius\"]($2, $3)"
         js_setRadius :: SVGFEMorphologyElement -> Float -> Float -> IO ()
@@ -47,6 +64,15 @@
 getIn1 self = liftIO (nullableToMaybe <$> (js_getIn1 (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFEMorphologyElement.in1 Mozilla SVGFEMorphologyElement.in1 documentation> 
+getIn1Unsafe ::
+             (MonadIO m, HasCallStack) =>
+               SVGFEMorphologyElement -> m SVGAnimatedString
+getIn1Unsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getIn1 (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFEMorphologyElement.in1 Mozilla SVGFEMorphologyElement.in1 documentation> 
 getIn1Unchecked ::
                 (MonadIO m) => SVGFEMorphologyElement -> m SVGAnimatedString
 getIn1Unchecked self
@@ -63,6 +89,15 @@
   = liftIO (nullableToMaybe <$> (js_getOperator (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFEMorphologyElement.operator Mozilla SVGFEMorphologyElement.operator documentation> 
+getOperatorUnsafe ::
+                  (MonadIO m, HasCallStack) =>
+                    SVGFEMorphologyElement -> m SVGAnimatedEnumeration
+getOperatorUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getOperator (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFEMorphologyElement.operator Mozilla SVGFEMorphologyElement.operator documentation> 
 getOperatorUnchecked ::
                      (MonadIO m) => SVGFEMorphologyElement -> m SVGAnimatedEnumeration
 getOperatorUnchecked self
@@ -79,6 +114,15 @@
   = liftIO (nullableToMaybe <$> (js_getRadiusX (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFEMorphologyElement.radiusX Mozilla SVGFEMorphologyElement.radiusX documentation> 
+getRadiusXUnsafe ::
+                 (MonadIO m, HasCallStack) =>
+                   SVGFEMorphologyElement -> m SVGAnimatedNumber
+getRadiusXUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getRadiusX (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFEMorphologyElement.radiusX Mozilla SVGFEMorphologyElement.radiusX documentation> 
 getRadiusXUnchecked ::
                     (MonadIO m) => SVGFEMorphologyElement -> m SVGAnimatedNumber
 getRadiusXUnchecked self
@@ -93,6 +137,15 @@
              SVGFEMorphologyElement -> m (Maybe SVGAnimatedNumber)
 getRadiusY self
   = liftIO (nullableToMaybe <$> (js_getRadiusY (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFEMorphologyElement.radiusY Mozilla SVGFEMorphologyElement.radiusY documentation> 
+getRadiusYUnsafe ::
+                 (MonadIO m, HasCallStack) =>
+                   SVGFEMorphologyElement -> m SVGAnimatedNumber
+getRadiusYUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getRadiusY (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFEMorphologyElement.radiusY Mozilla SVGFEMorphologyElement.radiusY documentation> 
 getRadiusYUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/SVGFEOffsetElement.hs b/src/GHCJS/DOM/JSFFI/Generated/SVGFEOffsetElement.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/SVGFEOffsetElement.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/SVGFEOffsetElement.hs
@@ -1,11 +1,16 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.SVGFEOffsetElement
-       (js_getIn1, getIn1, getIn1Unchecked, js_getDx, getDx,
-        getDxUnchecked, js_getDy, getDy, getDyUnchecked,
-        SVGFEOffsetElement, castToSVGFEOffsetElement,
-        gTypeSVGFEOffsetElement)
+       (js_getIn1, getIn1, getIn1Unsafe, getIn1Unchecked, js_getDx, getDx,
+        getDxUnsafe, getDxUnchecked, js_getDy, getDy, getDyUnsafe,
+        getDyUnchecked, SVGFEOffsetElement(..), gTypeSVGFEOffsetElement)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -21,6 +26,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"in1\"]" js_getIn1 ::
         SVGFEOffsetElement -> IO (Nullable SVGAnimatedString)
@@ -31,6 +46,15 @@
 getIn1 self = liftIO (nullableToMaybe <$> (js_getIn1 (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFEOffsetElement.in1 Mozilla SVGFEOffsetElement.in1 documentation> 
+getIn1Unsafe ::
+             (MonadIO m, HasCallStack) =>
+               SVGFEOffsetElement -> m SVGAnimatedString
+getIn1Unsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getIn1 (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFEOffsetElement.in1 Mozilla SVGFEOffsetElement.in1 documentation> 
 getIn1Unchecked ::
                 (MonadIO m) => SVGFEOffsetElement -> m SVGAnimatedString
 getIn1Unchecked self
@@ -45,6 +69,15 @@
 getDx self = liftIO (nullableToMaybe <$> (js_getDx (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFEOffsetElement.dx Mozilla SVGFEOffsetElement.dx documentation> 
+getDxUnsafe ::
+            (MonadIO m, HasCallStack) =>
+              SVGFEOffsetElement -> m SVGAnimatedNumber
+getDxUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getDx (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFEOffsetElement.dx Mozilla SVGFEOffsetElement.dx documentation> 
 getDxUnchecked ::
                (MonadIO m) => SVGFEOffsetElement -> m SVGAnimatedNumber
 getDxUnchecked self
@@ -57,6 +90,15 @@
 getDy ::
       (MonadIO m) => SVGFEOffsetElement -> m (Maybe SVGAnimatedNumber)
 getDy self = liftIO (nullableToMaybe <$> (js_getDy (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFEOffsetElement.dy Mozilla SVGFEOffsetElement.dy documentation> 
+getDyUnsafe ::
+            (MonadIO m, HasCallStack) =>
+              SVGFEOffsetElement -> m SVGAnimatedNumber
+getDyUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getDy (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFEOffsetElement.dy Mozilla SVGFEOffsetElement.dy documentation> 
 getDyUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/SVGFEPointLightElement.hs b/src/GHCJS/DOM/JSFFI/Generated/SVGFEPointLightElement.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/SVGFEPointLightElement.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/SVGFEPointLightElement.hs
@@ -1,10 +1,17 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.SVGFEPointLightElement
-       (js_getX, getX, getXUnchecked, js_getY, getY, getYUnchecked,
-        js_getZ, getZ, getZUnchecked, SVGFEPointLightElement,
-        castToSVGFEPointLightElement, gTypeSVGFEPointLightElement)
+       (js_getX, getX, getXUnsafe, getXUnchecked, js_getY, getY,
+        getYUnsafe, getYUnchecked, js_getZ, getZ, getZUnsafe,
+        getZUnchecked, SVGFEPointLightElement(..),
+        gTypeSVGFEPointLightElement)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -20,6 +27,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"x\"]" js_getX ::
         SVGFEPointLightElement -> IO (Nullable SVGAnimatedNumber)
@@ -31,6 +48,15 @@
 getX self = liftIO (nullableToMaybe <$> (js_getX (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFEPointLightElement.x Mozilla SVGFEPointLightElement.x documentation> 
+getXUnsafe ::
+           (MonadIO m, HasCallStack) =>
+             SVGFEPointLightElement -> m SVGAnimatedNumber
+getXUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getX (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFEPointLightElement.x Mozilla SVGFEPointLightElement.x documentation> 
 getXUnchecked ::
               (MonadIO m) => SVGFEPointLightElement -> m SVGAnimatedNumber
 getXUnchecked self
@@ -46,6 +72,15 @@
 getY self = liftIO (nullableToMaybe <$> (js_getY (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFEPointLightElement.y Mozilla SVGFEPointLightElement.y documentation> 
+getYUnsafe ::
+           (MonadIO m, HasCallStack) =>
+             SVGFEPointLightElement -> m SVGAnimatedNumber
+getYUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getY (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFEPointLightElement.y Mozilla SVGFEPointLightElement.y documentation> 
 getYUnchecked ::
               (MonadIO m) => SVGFEPointLightElement -> m SVGAnimatedNumber
 getYUnchecked self
@@ -59,6 +94,15 @@
      (MonadIO m) =>
        SVGFEPointLightElement -> m (Maybe SVGAnimatedNumber)
 getZ self = liftIO (nullableToMaybe <$> (js_getZ (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFEPointLightElement.z Mozilla SVGFEPointLightElement.z documentation> 
+getZUnsafe ::
+           (MonadIO m, HasCallStack) =>
+             SVGFEPointLightElement -> m SVGAnimatedNumber
+getZUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getZ (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFEPointLightElement.z Mozilla SVGFEPointLightElement.z documentation> 
 getZUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/SVGFESpecularLightingElement.hs b/src/GHCJS/DOM/JSFFI/Generated/SVGFESpecularLightingElement.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/SVGFESpecularLightingElement.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/SVGFESpecularLightingElement.hs
@@ -1,14 +1,21 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.SVGFESpecularLightingElement
-       (js_getIn1, getIn1, getIn1Unchecked, js_getSurfaceScale,
-        getSurfaceScale, getSurfaceScaleUnchecked, js_getSpecularConstant,
-        getSpecularConstant, getSpecularConstantUnchecked,
-        js_getSpecularExponent, getSpecularExponent,
-        getSpecularExponentUnchecked, SVGFESpecularLightingElement,
-        castToSVGFESpecularLightingElement,
+       (js_getIn1, getIn1, getIn1Unsafe, getIn1Unchecked,
+        js_getSurfaceScale, getSurfaceScale, getSurfaceScaleUnsafe,
+        getSurfaceScaleUnchecked, js_getSpecularConstant,
+        getSpecularConstant, getSpecularConstantUnsafe,
+        getSpecularConstantUnchecked, js_getSpecularExponent,
+        getSpecularExponent, getSpecularExponentUnsafe,
+        getSpecularExponentUnchecked, SVGFESpecularLightingElement(..),
         gTypeSVGFESpecularLightingElement)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -24,6 +31,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"in1\"]" js_getIn1 ::
         SVGFESpecularLightingElement -> IO (Nullable SVGAnimatedString)
@@ -35,6 +52,15 @@
 getIn1 self = liftIO (nullableToMaybe <$> (js_getIn1 (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFESpecularLightingElement.in1 Mozilla SVGFESpecularLightingElement.in1 documentation> 
+getIn1Unsafe ::
+             (MonadIO m, HasCallStack) =>
+               SVGFESpecularLightingElement -> m SVGAnimatedString
+getIn1Unsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getIn1 (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFESpecularLightingElement.in1 Mozilla SVGFESpecularLightingElement.in1 documentation> 
 getIn1Unchecked ::
                 (MonadIO m) => SVGFESpecularLightingElement -> m SVGAnimatedString
 getIn1Unchecked self
@@ -52,6 +78,15 @@
   = liftIO (nullableToMaybe <$> (js_getSurfaceScale (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFESpecularLightingElement.surfaceScale Mozilla SVGFESpecularLightingElement.surfaceScale documentation> 
+getSurfaceScaleUnsafe ::
+                      (MonadIO m, HasCallStack) =>
+                        SVGFESpecularLightingElement -> m SVGAnimatedNumber
+getSurfaceScaleUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getSurfaceScale (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFESpecularLightingElement.surfaceScale Mozilla SVGFESpecularLightingElement.surfaceScale documentation> 
 getSurfaceScaleUnchecked ::
                          (MonadIO m) => SVGFESpecularLightingElement -> m SVGAnimatedNumber
 getSurfaceScaleUnchecked self
@@ -70,6 +105,15 @@
   = liftIO (nullableToMaybe <$> (js_getSpecularConstant (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFESpecularLightingElement.specularConstant Mozilla SVGFESpecularLightingElement.specularConstant documentation> 
+getSpecularConstantUnsafe ::
+                          (MonadIO m, HasCallStack) =>
+                            SVGFESpecularLightingElement -> m SVGAnimatedNumber
+getSpecularConstantUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getSpecularConstant (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFESpecularLightingElement.specularConstant Mozilla SVGFESpecularLightingElement.specularConstant documentation> 
 getSpecularConstantUnchecked ::
                              (MonadIO m) => SVGFESpecularLightingElement -> m SVGAnimatedNumber
 getSpecularConstantUnchecked self
@@ -86,6 +130,15 @@
                       SVGFESpecularLightingElement -> m (Maybe SVGAnimatedNumber)
 getSpecularExponent self
   = liftIO (nullableToMaybe <$> (js_getSpecularExponent (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFESpecularLightingElement.specularExponent Mozilla SVGFESpecularLightingElement.specularExponent documentation> 
+getSpecularExponentUnsafe ::
+                          (MonadIO m, HasCallStack) =>
+                            SVGFESpecularLightingElement -> m SVGAnimatedNumber
+getSpecularExponentUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getSpecularExponent (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFESpecularLightingElement.specularExponent Mozilla SVGFESpecularLightingElement.specularExponent documentation> 
 getSpecularExponentUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/SVGFESpotLightElement.hs b/src/GHCJS/DOM/JSFFI/Generated/SVGFESpotLightElement.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/SVGFESpotLightElement.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/SVGFESpotLightElement.hs
@@ -1,16 +1,24 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.SVGFESpotLightElement
-       (js_getX, getX, getXUnchecked, js_getY, getY, getYUnchecked,
-        js_getZ, getZ, getZUnchecked, js_getPointsAtX, getPointsAtX,
+       (js_getX, getX, getXUnsafe, getXUnchecked, js_getY, getY,
+        getYUnsafe, getYUnchecked, js_getZ, getZ, getZUnsafe,
+        getZUnchecked, js_getPointsAtX, getPointsAtX, getPointsAtXUnsafe,
         getPointsAtXUnchecked, js_getPointsAtY, getPointsAtY,
-        getPointsAtYUnchecked, js_getPointsAtZ, getPointsAtZ,
-        getPointsAtZUnchecked, js_getSpecularExponent, getSpecularExponent,
-        getSpecularExponentUnchecked, js_getLimitingConeAngle,
-        getLimitingConeAngle, getLimitingConeAngleUnchecked,
-        SVGFESpotLightElement, castToSVGFESpotLightElement,
-        gTypeSVGFESpotLightElement)
+        getPointsAtYUnsafe, getPointsAtYUnchecked, js_getPointsAtZ,
+        getPointsAtZ, getPointsAtZUnsafe, getPointsAtZUnchecked,
+        js_getSpecularExponent, getSpecularExponent,
+        getSpecularExponentUnsafe, getSpecularExponentUnchecked,
+        js_getLimitingConeAngle, getLimitingConeAngle,
+        getLimitingConeAngleUnsafe, getLimitingConeAngleUnchecked,
+        SVGFESpotLightElement(..), gTypeSVGFESpotLightElement)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -26,6 +34,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"x\"]" js_getX ::
         SVGFESpotLightElement -> IO (Nullable SVGAnimatedNumber)
@@ -36,6 +54,15 @@
 getX self = liftIO (nullableToMaybe <$> (js_getX (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFESpotLightElement.x Mozilla SVGFESpotLightElement.x documentation> 
+getXUnsafe ::
+           (MonadIO m, HasCallStack) =>
+             SVGFESpotLightElement -> m SVGAnimatedNumber
+getXUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getX (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFESpotLightElement.x Mozilla SVGFESpotLightElement.x documentation> 
 getXUnchecked ::
               (MonadIO m) => SVGFESpotLightElement -> m SVGAnimatedNumber
 getXUnchecked self
@@ -50,6 +77,15 @@
 getY self = liftIO (nullableToMaybe <$> (js_getY (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFESpotLightElement.y Mozilla SVGFESpotLightElement.y documentation> 
+getYUnsafe ::
+           (MonadIO m, HasCallStack) =>
+             SVGFESpotLightElement -> m SVGAnimatedNumber
+getYUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getY (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFESpotLightElement.y Mozilla SVGFESpotLightElement.y documentation> 
 getYUnchecked ::
               (MonadIO m) => SVGFESpotLightElement -> m SVGAnimatedNumber
 getYUnchecked self
@@ -64,6 +100,15 @@
 getZ self = liftIO (nullableToMaybe <$> (js_getZ (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFESpotLightElement.z Mozilla SVGFESpotLightElement.z documentation> 
+getZUnsafe ::
+           (MonadIO m, HasCallStack) =>
+             SVGFESpotLightElement -> m SVGAnimatedNumber
+getZUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getZ (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFESpotLightElement.z Mozilla SVGFESpotLightElement.z documentation> 
 getZUnchecked ::
               (MonadIO m) => SVGFESpotLightElement -> m SVGAnimatedNumber
 getZUnchecked self
@@ -80,6 +125,15 @@
   = liftIO (nullableToMaybe <$> (js_getPointsAtX (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFESpotLightElement.pointsAtX Mozilla SVGFESpotLightElement.pointsAtX documentation> 
+getPointsAtXUnsafe ::
+                   (MonadIO m, HasCallStack) =>
+                     SVGFESpotLightElement -> m SVGAnimatedNumber
+getPointsAtXUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getPointsAtX (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFESpotLightElement.pointsAtX Mozilla SVGFESpotLightElement.pointsAtX documentation> 
 getPointsAtXUnchecked ::
                       (MonadIO m) => SVGFESpotLightElement -> m SVGAnimatedNumber
 getPointsAtXUnchecked self
@@ -96,6 +150,15 @@
   = liftIO (nullableToMaybe <$> (js_getPointsAtY (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFESpotLightElement.pointsAtY Mozilla SVGFESpotLightElement.pointsAtY documentation> 
+getPointsAtYUnsafe ::
+                   (MonadIO m, HasCallStack) =>
+                     SVGFESpotLightElement -> m SVGAnimatedNumber
+getPointsAtYUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getPointsAtY (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFESpotLightElement.pointsAtY Mozilla SVGFESpotLightElement.pointsAtY documentation> 
 getPointsAtYUnchecked ::
                       (MonadIO m) => SVGFESpotLightElement -> m SVGAnimatedNumber
 getPointsAtYUnchecked self
@@ -112,6 +175,15 @@
   = liftIO (nullableToMaybe <$> (js_getPointsAtZ (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFESpotLightElement.pointsAtZ Mozilla SVGFESpotLightElement.pointsAtZ documentation> 
+getPointsAtZUnsafe ::
+                   (MonadIO m, HasCallStack) =>
+                     SVGFESpotLightElement -> m SVGAnimatedNumber
+getPointsAtZUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getPointsAtZ (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFESpotLightElement.pointsAtZ Mozilla SVGFESpotLightElement.pointsAtZ documentation> 
 getPointsAtZUnchecked ::
                       (MonadIO m) => SVGFESpotLightElement -> m SVGAnimatedNumber
 getPointsAtZUnchecked self
@@ -128,6 +200,15 @@
   = liftIO (nullableToMaybe <$> (js_getSpecularExponent (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFESpotLightElement.specularExponent Mozilla SVGFESpotLightElement.specularExponent documentation> 
+getSpecularExponentUnsafe ::
+                          (MonadIO m, HasCallStack) =>
+                            SVGFESpotLightElement -> m SVGAnimatedNumber
+getSpecularExponentUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getSpecularExponent (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFESpotLightElement.specularExponent Mozilla SVGFESpotLightElement.specularExponent documentation> 
 getSpecularExponentUnchecked ::
                              (MonadIO m) => SVGFESpotLightElement -> m SVGAnimatedNumber
 getSpecularExponentUnchecked self
@@ -143,6 +224,15 @@
                      (MonadIO m) => SVGFESpotLightElement -> m (Maybe SVGAnimatedNumber)
 getLimitingConeAngle self
   = liftIO (nullableToMaybe <$> (js_getLimitingConeAngle (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFESpotLightElement.limitingConeAngle Mozilla SVGFESpotLightElement.limitingConeAngle documentation> 
+getLimitingConeAngleUnsafe ::
+                           (MonadIO m, HasCallStack) =>
+                             SVGFESpotLightElement -> m SVGAnimatedNumber
+getLimitingConeAngleUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getLimitingConeAngle (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFESpotLightElement.limitingConeAngle Mozilla SVGFESpotLightElement.limitingConeAngle documentation> 
 getLimitingConeAngleUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/SVGFETileElement.hs b/src/GHCJS/DOM/JSFFI/Generated/SVGFETileElement.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/SVGFETileElement.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/SVGFETileElement.hs
@@ -1,9 +1,15 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.SVGFETileElement
-       (js_getIn1, getIn1, getIn1Unchecked, SVGFETileElement,
-        castToSVGFETileElement, gTypeSVGFETileElement)
+       (js_getIn1, getIn1, getIn1Unsafe, getIn1Unchecked,
+        SVGFETileElement(..), gTypeSVGFETileElement)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -19,6 +25,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"in1\"]" js_getIn1 ::
         SVGFETileElement -> IO (Nullable SVGAnimatedString)
@@ -27,6 +43,15 @@
 getIn1 ::
        (MonadIO m) => SVGFETileElement -> m (Maybe SVGAnimatedString)
 getIn1 self = liftIO (nullableToMaybe <$> (js_getIn1 (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFETileElement.in1 Mozilla SVGFETileElement.in1 documentation> 
+getIn1Unsafe ::
+             (MonadIO m, HasCallStack) =>
+               SVGFETileElement -> m SVGAnimatedString
+getIn1Unsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getIn1 (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFETileElement.in1 Mozilla SVGFETileElement.in1 documentation> 
 getIn1Unchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/SVGFETurbulenceElement.hs b/src/GHCJS/DOM/JSFFI/Generated/SVGFETurbulenceElement.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/SVGFETurbulenceElement.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/SVGFETurbulenceElement.hs
@@ -1,19 +1,27 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.SVGFETurbulenceElement
        (pattern SVG_TURBULENCE_TYPE_UNKNOWN,
         pattern SVG_TURBULENCE_TYPE_FRACTALNOISE,
         pattern SVG_TURBULENCE_TYPE_TURBULENCE,
         pattern SVG_STITCHTYPE_UNKNOWN, pattern SVG_STITCHTYPE_STITCH,
         pattern SVG_STITCHTYPE_NOSTITCH, js_getBaseFrequencyX,
-        getBaseFrequencyX, getBaseFrequencyXUnchecked,
-        js_getBaseFrequencyY, getBaseFrequencyY,
+        getBaseFrequencyX, getBaseFrequencyXUnsafe,
+        getBaseFrequencyXUnchecked, js_getBaseFrequencyY,
+        getBaseFrequencyY, getBaseFrequencyYUnsafe,
         getBaseFrequencyYUnchecked, js_getNumOctaves, getNumOctaves,
-        getNumOctavesUnchecked, js_getSeed, getSeed, getSeedUnchecked,
-        js_getStitchTiles, getStitchTiles, getStitchTilesUnchecked,
-        js_getType, getType, getTypeUnchecked, SVGFETurbulenceElement,
-        castToSVGFETurbulenceElement, gTypeSVGFETurbulenceElement)
+        getNumOctavesUnsafe, getNumOctavesUnchecked, js_getSeed, getSeed,
+        getSeedUnsafe, getSeedUnchecked, js_getStitchTiles, getStitchTiles,
+        getStitchTilesUnsafe, getStitchTilesUnchecked, js_getType, getType,
+        getTypeUnsafe, getTypeUnchecked, SVGFETurbulenceElement(..),
+        gTypeSVGFETurbulenceElement)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -29,6 +37,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
 pattern SVG_TURBULENCE_TYPE_UNKNOWN = 0
 pattern SVG_TURBULENCE_TYPE_FRACTALNOISE = 1
 pattern SVG_TURBULENCE_TYPE_TURBULENCE = 2
@@ -48,6 +66,15 @@
   = liftIO (nullableToMaybe <$> (js_getBaseFrequencyX (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFETurbulenceElement.baseFrequencyX Mozilla SVGFETurbulenceElement.baseFrequencyX documentation> 
+getBaseFrequencyXUnsafe ::
+                        (MonadIO m, HasCallStack) =>
+                          SVGFETurbulenceElement -> m SVGAnimatedNumber
+getBaseFrequencyXUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getBaseFrequencyX (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFETurbulenceElement.baseFrequencyX Mozilla SVGFETurbulenceElement.baseFrequencyX documentation> 
 getBaseFrequencyXUnchecked ::
                            (MonadIO m) => SVGFETurbulenceElement -> m SVGAnimatedNumber
 getBaseFrequencyXUnchecked self
@@ -66,6 +93,15 @@
   = liftIO (nullableToMaybe <$> (js_getBaseFrequencyY (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFETurbulenceElement.baseFrequencyY Mozilla SVGFETurbulenceElement.baseFrequencyY documentation> 
+getBaseFrequencyYUnsafe ::
+                        (MonadIO m, HasCallStack) =>
+                          SVGFETurbulenceElement -> m SVGAnimatedNumber
+getBaseFrequencyYUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getBaseFrequencyY (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFETurbulenceElement.baseFrequencyY Mozilla SVGFETurbulenceElement.baseFrequencyY documentation> 
 getBaseFrequencyYUnchecked ::
                            (MonadIO m) => SVGFETurbulenceElement -> m SVGAnimatedNumber
 getBaseFrequencyYUnchecked self
@@ -84,6 +120,15 @@
   = liftIO (nullableToMaybe <$> (js_getNumOctaves (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFETurbulenceElement.numOctaves Mozilla SVGFETurbulenceElement.numOctaves documentation> 
+getNumOctavesUnsafe ::
+                    (MonadIO m, HasCallStack) =>
+                      SVGFETurbulenceElement -> m SVGAnimatedInteger
+getNumOctavesUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getNumOctaves (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFETurbulenceElement.numOctaves Mozilla SVGFETurbulenceElement.numOctaves documentation> 
 getNumOctavesUnchecked ::
                        (MonadIO m) => SVGFETurbulenceElement -> m SVGAnimatedInteger
 getNumOctavesUnchecked self
@@ -99,6 +144,15 @@
 getSeed self = liftIO (nullableToMaybe <$> (js_getSeed (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFETurbulenceElement.seed Mozilla SVGFETurbulenceElement.seed documentation> 
+getSeedUnsafe ::
+              (MonadIO m, HasCallStack) =>
+                SVGFETurbulenceElement -> m SVGAnimatedNumber
+getSeedUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getSeed (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFETurbulenceElement.seed Mozilla SVGFETurbulenceElement.seed documentation> 
 getSeedUnchecked ::
                  (MonadIO m) => SVGFETurbulenceElement -> m SVGAnimatedNumber
 getSeedUnchecked self
@@ -116,6 +170,15 @@
   = liftIO (nullableToMaybe <$> (js_getStitchTiles (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFETurbulenceElement.stitchTiles Mozilla SVGFETurbulenceElement.stitchTiles documentation> 
+getStitchTilesUnsafe ::
+                     (MonadIO m, HasCallStack) =>
+                       SVGFETurbulenceElement -> m SVGAnimatedEnumeration
+getStitchTilesUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getStitchTiles (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFETurbulenceElement.stitchTiles Mozilla SVGFETurbulenceElement.stitchTiles documentation> 
 getStitchTilesUnchecked ::
                         (MonadIO m) => SVGFETurbulenceElement -> m SVGAnimatedEnumeration
 getStitchTilesUnchecked self
@@ -130,6 +193,15 @@
         (MonadIO m) =>
           SVGFETurbulenceElement -> m (Maybe SVGAnimatedEnumeration)
 getType self = liftIO (nullableToMaybe <$> (js_getType (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFETurbulenceElement.type Mozilla SVGFETurbulenceElement.type documentation> 
+getTypeUnsafe ::
+              (MonadIO m, HasCallStack) =>
+                SVGFETurbulenceElement -> m SVGAnimatedEnumeration
+getTypeUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getType (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFETurbulenceElement.type Mozilla SVGFETurbulenceElement.type documentation> 
 getTypeUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/SVGFilterElement.hs b/src/GHCJS/DOM/JSFFI/Generated/SVGFilterElement.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/SVGFilterElement.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/SVGFilterElement.hs
@@ -1,15 +1,24 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.SVGFilterElement
        (js_setFilterRes, setFilterRes, js_getFilterUnits, getFilterUnits,
-        getFilterUnitsUnchecked, js_getPrimitiveUnits, getPrimitiveUnits,
-        getPrimitiveUnitsUnchecked, js_getX, getX, getXUnchecked, js_getY,
-        getY, getYUnchecked, js_getWidth, getWidth, getWidthUnchecked,
-        js_getHeight, getHeight, getHeightUnchecked, js_getFilterResX,
-        getFilterResX, getFilterResXUnchecked, js_getFilterResY,
-        getFilterResY, getFilterResYUnchecked, SVGFilterElement,
-        castToSVGFilterElement, gTypeSVGFilterElement)
+        getFilterUnitsUnsafe, getFilterUnitsUnchecked,
+        js_getPrimitiveUnits, getPrimitiveUnits, getPrimitiveUnitsUnsafe,
+        getPrimitiveUnitsUnchecked, js_getX, getX, getXUnsafe,
+        getXUnchecked, js_getY, getY, getYUnsafe, getYUnchecked,
+        js_getWidth, getWidth, getWidthUnsafe, getWidthUnchecked,
+        js_getHeight, getHeight, getHeightUnsafe, getHeightUnchecked,
+        js_getFilterResX, getFilterResX, getFilterResXUnsafe,
+        getFilterResXUnchecked, js_getFilterResY, getFilterResY,
+        getFilterResYUnsafe, getFilterResYUnchecked, SVGFilterElement(..),
+        gTypeSVGFilterElement)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -25,6 +34,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"setFilterRes\"]($2, $3)"
         js_setFilterRes :: SVGFilterElement -> Word -> Word -> IO ()
@@ -46,6 +65,15 @@
   = liftIO (nullableToMaybe <$> (js_getFilterUnits (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFilterElement.filterUnits Mozilla SVGFilterElement.filterUnits documentation> 
+getFilterUnitsUnsafe ::
+                     (MonadIO m, HasCallStack) =>
+                       SVGFilterElement -> m SVGAnimatedEnumeration
+getFilterUnitsUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getFilterUnits (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFilterElement.filterUnits Mozilla SVGFilterElement.filterUnits documentation> 
 getFilterUnitsUnchecked ::
                         (MonadIO m) => SVGFilterElement -> m SVGAnimatedEnumeration
 getFilterUnitsUnchecked self
@@ -63,6 +91,15 @@
   = liftIO (nullableToMaybe <$> (js_getPrimitiveUnits (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFilterElement.primitiveUnits Mozilla SVGFilterElement.primitiveUnits documentation> 
+getPrimitiveUnitsUnsafe ::
+                        (MonadIO m, HasCallStack) =>
+                          SVGFilterElement -> m SVGAnimatedEnumeration
+getPrimitiveUnitsUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getPrimitiveUnits (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFilterElement.primitiveUnits Mozilla SVGFilterElement.primitiveUnits documentation> 
 getPrimitiveUnitsUnchecked ::
                            (MonadIO m) => SVGFilterElement -> m SVGAnimatedEnumeration
 getPrimitiveUnitsUnchecked self
@@ -78,6 +115,15 @@
 getX self = liftIO (nullableToMaybe <$> (js_getX (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFilterElement.x Mozilla SVGFilterElement.x documentation> 
+getXUnsafe ::
+           (MonadIO m, HasCallStack) =>
+             SVGFilterElement -> m SVGAnimatedLength
+getXUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getX (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFilterElement.x Mozilla SVGFilterElement.x documentation> 
 getXUnchecked ::
               (MonadIO m) => SVGFilterElement -> m SVGAnimatedLength
 getXUnchecked self
@@ -92,6 +138,15 @@
 getY self = liftIO (nullableToMaybe <$> (js_getY (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFilterElement.y Mozilla SVGFilterElement.y documentation> 
+getYUnsafe ::
+           (MonadIO m, HasCallStack) =>
+             SVGFilterElement -> m SVGAnimatedLength
+getYUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getY (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFilterElement.y Mozilla SVGFilterElement.y documentation> 
 getYUnchecked ::
               (MonadIO m) => SVGFilterElement -> m SVGAnimatedLength
 getYUnchecked self
@@ -106,6 +161,15 @@
 getWidth self = liftIO (nullableToMaybe <$> (js_getWidth (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFilterElement.width Mozilla SVGFilterElement.width documentation> 
+getWidthUnsafe ::
+               (MonadIO m, HasCallStack) =>
+                 SVGFilterElement -> m SVGAnimatedLength
+getWidthUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getWidth (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFilterElement.width Mozilla SVGFilterElement.width documentation> 
 getWidthUnchecked ::
                   (MonadIO m) => SVGFilterElement -> m SVGAnimatedLength
 getWidthUnchecked self
@@ -120,6 +184,15 @@
 getHeight self = liftIO (nullableToMaybe <$> (js_getHeight (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFilterElement.height Mozilla SVGFilterElement.height documentation> 
+getHeightUnsafe ::
+                (MonadIO m, HasCallStack) =>
+                  SVGFilterElement -> m SVGAnimatedLength
+getHeightUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getHeight (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFilterElement.height Mozilla SVGFilterElement.height documentation> 
 getHeightUnchecked ::
                    (MonadIO m) => SVGFilterElement -> m SVGAnimatedLength
 getHeightUnchecked self
@@ -136,6 +209,15 @@
   = liftIO (nullableToMaybe <$> (js_getFilterResX (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFilterElement.filterResX Mozilla SVGFilterElement.filterResX documentation> 
+getFilterResXUnsafe ::
+                    (MonadIO m, HasCallStack) =>
+                      SVGFilterElement -> m SVGAnimatedInteger
+getFilterResXUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getFilterResX (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFilterElement.filterResX Mozilla SVGFilterElement.filterResX documentation> 
 getFilterResXUnchecked ::
                        (MonadIO m) => SVGFilterElement -> m SVGAnimatedInteger
 getFilterResXUnchecked self
@@ -150,6 +232,15 @@
               (MonadIO m) => SVGFilterElement -> m (Maybe SVGAnimatedInteger)
 getFilterResY self
   = liftIO (nullableToMaybe <$> (js_getFilterResY (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFilterElement.filterResY Mozilla SVGFilterElement.filterResY documentation> 
+getFilterResYUnsafe ::
+                    (MonadIO m, HasCallStack) =>
+                      SVGFilterElement -> m SVGAnimatedInteger
+getFilterResYUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getFilterResY (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFilterElement.filterResY Mozilla SVGFilterElement.filterResY documentation> 
 getFilterResYUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/SVGFilterPrimitiveStandardAttributes.hs b/src/GHCJS/DOM/JSFFI/Generated/SVGFilterPrimitiveStandardAttributes.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/SVGFilterPrimitiveStandardAttributes.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/SVGFilterPrimitiveStandardAttributes.hs
@@ -1,13 +1,19 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.SVGFilterPrimitiveStandardAttributes
-       (js_getX, getX, getXUnchecked, js_getY, getY, getYUnchecked,
-        js_getWidth, getWidth, getWidthUnchecked, js_getHeight, getHeight,
-        getHeightUnchecked, js_getResult, getResult, getResultUnchecked,
-        SVGFilterPrimitiveStandardAttributes,
-        castToSVGFilterPrimitiveStandardAttributes,
+       (js_getX, getX, getXUnsafe, getXUnchecked, js_getY, getY,
+        getYUnsafe, getYUnchecked, js_getWidth, getWidth, getWidthUnsafe,
+        getWidthUnchecked, js_getHeight, getHeight, getHeightUnsafe,
+        getHeightUnchecked, js_getResult, getResult, getResultUnsafe,
+        getResultUnchecked, SVGFilterPrimitiveStandardAttributes(..),
         gTypeSVGFilterPrimitiveStandardAttributes)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -23,6 +29,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"x\"]" js_getX ::
         SVGFilterPrimitiveStandardAttributes ->
@@ -35,6 +51,15 @@
 getX self = liftIO (nullableToMaybe <$> (js_getX (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFilterPrimitiveStandardAttributes.x Mozilla SVGFilterPrimitiveStandardAttributes.x documentation> 
+getXUnsafe ::
+           (MonadIO m, HasCallStack) =>
+             SVGFilterPrimitiveStandardAttributes -> m SVGAnimatedLength
+getXUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getX (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFilterPrimitiveStandardAttributes.x Mozilla SVGFilterPrimitiveStandardAttributes.x documentation> 
 getXUnchecked ::
               (MonadIO m) =>
                 SVGFilterPrimitiveStandardAttributes -> m SVGAnimatedLength
@@ -52,6 +77,15 @@
 getY self = liftIO (nullableToMaybe <$> (js_getY (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFilterPrimitiveStandardAttributes.y Mozilla SVGFilterPrimitiveStandardAttributes.y documentation> 
+getYUnsafe ::
+           (MonadIO m, HasCallStack) =>
+             SVGFilterPrimitiveStandardAttributes -> m SVGAnimatedLength
+getYUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getY (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFilterPrimitiveStandardAttributes.y Mozilla SVGFilterPrimitiveStandardAttributes.y documentation> 
 getYUnchecked ::
               (MonadIO m) =>
                 SVGFilterPrimitiveStandardAttributes -> m SVGAnimatedLength
@@ -69,6 +103,15 @@
 getWidth self = liftIO (nullableToMaybe <$> (js_getWidth (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFilterPrimitiveStandardAttributes.width Mozilla SVGFilterPrimitiveStandardAttributes.width documentation> 
+getWidthUnsafe ::
+               (MonadIO m, HasCallStack) =>
+                 SVGFilterPrimitiveStandardAttributes -> m SVGAnimatedLength
+getWidthUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getWidth (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFilterPrimitiveStandardAttributes.width Mozilla SVGFilterPrimitiveStandardAttributes.width documentation> 
 getWidthUnchecked ::
                   (MonadIO m) =>
                     SVGFilterPrimitiveStandardAttributes -> m SVGAnimatedLength
@@ -86,6 +129,15 @@
 getHeight self = liftIO (nullableToMaybe <$> (js_getHeight (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFilterPrimitiveStandardAttributes.height Mozilla SVGFilterPrimitiveStandardAttributes.height documentation> 
+getHeightUnsafe ::
+                (MonadIO m, HasCallStack) =>
+                  SVGFilterPrimitiveStandardAttributes -> m SVGAnimatedLength
+getHeightUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getHeight (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFilterPrimitiveStandardAttributes.height Mozilla SVGFilterPrimitiveStandardAttributes.height documentation> 
 getHeightUnchecked ::
                    (MonadIO m) =>
                      SVGFilterPrimitiveStandardAttributes -> m SVGAnimatedLength
@@ -101,6 +153,15 @@
           (MonadIO m) =>
             SVGFilterPrimitiveStandardAttributes -> m (Maybe SVGAnimatedString)
 getResult self = liftIO (nullableToMaybe <$> (js_getResult (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFilterPrimitiveStandardAttributes.result Mozilla SVGFilterPrimitiveStandardAttributes.result documentation> 
+getResultUnsafe ::
+                (MonadIO m, HasCallStack) =>
+                  SVGFilterPrimitiveStandardAttributes -> m SVGAnimatedString
+getResultUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getResult (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFilterPrimitiveStandardAttributes.result Mozilla SVGFilterPrimitiveStandardAttributes.result documentation> 
 getResultUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/SVGFitToViewBox.hs b/src/GHCJS/DOM/JSFFI/Generated/SVGFitToViewBox.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/SVGFitToViewBox.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/SVGFitToViewBox.hs
@@ -1,11 +1,17 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.SVGFitToViewBox
-       (js_getViewBox, getViewBox, getViewBoxUnchecked,
+       (js_getViewBox, getViewBox, getViewBoxUnsafe, getViewBoxUnchecked,
         js_getPreserveAspectRatio, getPreserveAspectRatio,
-        getPreserveAspectRatioUnchecked, SVGFitToViewBox,
-        castToSVGFitToViewBox, gTypeSVGFitToViewBox)
+        getPreserveAspectRatioUnsafe, getPreserveAspectRatioUnchecked,
+        SVGFitToViewBox(..), gTypeSVGFitToViewBox)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -21,6 +27,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"viewBox\"]" js_getViewBox ::
         SVGFitToViewBox -> IO (Nullable SVGAnimatedRect)
@@ -32,6 +48,14 @@
   = liftIO (nullableToMaybe <$> (js_getViewBox (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFitToViewBox.viewBox Mozilla SVGFitToViewBox.viewBox documentation> 
+getViewBoxUnsafe ::
+                 (MonadIO m, HasCallStack) => SVGFitToViewBox -> m SVGAnimatedRect
+getViewBoxUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getViewBox (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFitToViewBox.viewBox Mozilla SVGFitToViewBox.viewBox documentation> 
 getViewBoxUnchecked ::
                     (MonadIO m) => SVGFitToViewBox -> m SVGAnimatedRect
 getViewBoxUnchecked self
@@ -47,6 +71,15 @@
                          SVGFitToViewBox -> m (Maybe SVGAnimatedPreserveAspectRatio)
 getPreserveAspectRatio self
   = liftIO (nullableToMaybe <$> (js_getPreserveAspectRatio (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFitToViewBox.preserveAspectRatio Mozilla SVGFitToViewBox.preserveAspectRatio documentation> 
+getPreserveAspectRatioUnsafe ::
+                             (MonadIO m, HasCallStack) =>
+                               SVGFitToViewBox -> m SVGAnimatedPreserveAspectRatio
+getPreserveAspectRatioUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getPreserveAspectRatio (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGFitToViewBox.preserveAspectRatio Mozilla SVGFitToViewBox.preserveAspectRatio documentation> 
 getPreserveAspectRatioUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/SVGForeignObjectElement.hs b/src/GHCJS/DOM/JSFFI/Generated/SVGForeignObjectElement.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/SVGForeignObjectElement.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/SVGForeignObjectElement.hs
@@ -1,11 +1,18 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.SVGForeignObjectElement
-       (js_getX, getX, getXUnchecked, js_getY, getY, getYUnchecked,
-        js_getWidth, getWidth, getWidthUnchecked, js_getHeight, getHeight,
-        getHeightUnchecked, SVGForeignObjectElement,
-        castToSVGForeignObjectElement, gTypeSVGForeignObjectElement)
+       (js_getX, getX, getXUnsafe, getXUnchecked, js_getY, getY,
+        getYUnsafe, getYUnchecked, js_getWidth, getWidth, getWidthUnsafe,
+        getWidthUnchecked, js_getHeight, getHeight, getHeightUnsafe,
+        getHeightUnchecked, SVGForeignObjectElement(..),
+        gTypeSVGForeignObjectElement)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -21,6 +28,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"x\"]" js_getX ::
         SVGForeignObjectElement -> IO (Nullable SVGAnimatedLength)
@@ -32,6 +49,15 @@
 getX self = liftIO (nullableToMaybe <$> (js_getX (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGForeignObjectElement.x Mozilla SVGForeignObjectElement.x documentation> 
+getXUnsafe ::
+           (MonadIO m, HasCallStack) =>
+             SVGForeignObjectElement -> m SVGAnimatedLength
+getXUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getX (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGForeignObjectElement.x Mozilla SVGForeignObjectElement.x documentation> 
 getXUnchecked ::
               (MonadIO m) => SVGForeignObjectElement -> m SVGAnimatedLength
 getXUnchecked self
@@ -47,6 +73,15 @@
 getY self = liftIO (nullableToMaybe <$> (js_getY (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGForeignObjectElement.y Mozilla SVGForeignObjectElement.y documentation> 
+getYUnsafe ::
+           (MonadIO m, HasCallStack) =>
+             SVGForeignObjectElement -> m SVGAnimatedLength
+getYUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getY (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGForeignObjectElement.y Mozilla SVGForeignObjectElement.y documentation> 
 getYUnchecked ::
               (MonadIO m) => SVGForeignObjectElement -> m SVGAnimatedLength
 getYUnchecked self
@@ -62,6 +97,15 @@
 getWidth self = liftIO (nullableToMaybe <$> (js_getWidth (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGForeignObjectElement.width Mozilla SVGForeignObjectElement.width documentation> 
+getWidthUnsafe ::
+               (MonadIO m, HasCallStack) =>
+                 SVGForeignObjectElement -> m SVGAnimatedLength
+getWidthUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getWidth (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGForeignObjectElement.width Mozilla SVGForeignObjectElement.width documentation> 
 getWidthUnchecked ::
                   (MonadIO m) => SVGForeignObjectElement -> m SVGAnimatedLength
 getWidthUnchecked self
@@ -75,6 +119,15 @@
           (MonadIO m) =>
             SVGForeignObjectElement -> m (Maybe SVGAnimatedLength)
 getHeight self = liftIO (nullableToMaybe <$> (js_getHeight (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGForeignObjectElement.height Mozilla SVGForeignObjectElement.height documentation> 
+getHeightUnsafe ::
+                (MonadIO m, HasCallStack) =>
+                  SVGForeignObjectElement -> m SVGAnimatedLength
+getHeightUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getHeight (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGForeignObjectElement.height Mozilla SVGForeignObjectElement.height documentation> 
 getHeightUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/SVGGlyphRefElement.hs b/src/GHCJS/DOM/JSFFI/Generated/SVGGlyphRefElement.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/SVGGlyphRefElement.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/SVGGlyphRefElement.hs
@@ -1,13 +1,18 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.SVGGlyphRefElement
        (js_setGlyphRef, setGlyphRef, js_getGlyphRef, getGlyphRef,
         js_setFormat, setFormat, js_getFormat, getFormat, js_setX, setX,
         js_getX, getX, js_setY, setY, js_getY, getY, js_setDx, setDx,
         js_getDx, getDx, js_setDy, setDy, js_getDy, getDy,
-        SVGGlyphRefElement, castToSVGGlyphRefElement,
-        gTypeSVGGlyphRefElement)
+        SVGGlyphRefElement(..), gTypeSVGGlyphRefElement)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -23,6 +28,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"glyphRef\"] = $2;"
         js_setGlyphRef :: SVGGlyphRefElement -> JSString -> IO ()
diff --git a/src/GHCJS/DOM/JSFFI/Generated/SVGGradientElement.hs b/src/GHCJS/DOM/JSFFI/Generated/SVGGradientElement.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/SVGGradientElement.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/SVGGradientElement.hs
@@ -1,15 +1,22 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.SVGGradientElement
        (pattern SVG_SPREADMETHOD_UNKNOWN, pattern SVG_SPREADMETHOD_PAD,
         pattern SVG_SPREADMETHOD_REFLECT, pattern SVG_SPREADMETHOD_REPEAT,
-        js_getGradientUnits, getGradientUnits, getGradientUnitsUnchecked,
-        js_getGradientTransform, getGradientTransform,
+        js_getGradientUnits, getGradientUnits, getGradientUnitsUnsafe,
+        getGradientUnitsUnchecked, js_getGradientTransform,
+        getGradientTransform, getGradientTransformUnsafe,
         getGradientTransformUnchecked, js_getSpreadMethod, getSpreadMethod,
-        getSpreadMethodUnchecked, SVGGradientElement,
-        castToSVGGradientElement, gTypeSVGGradientElement,
+        getSpreadMethodUnsafe, getSpreadMethodUnchecked,
+        SVGGradientElement(..), gTypeSVGGradientElement,
         IsSVGGradientElement, toSVGGradientElement)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -25,6 +32,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
 pattern SVG_SPREADMETHOD_UNKNOWN = 0
 pattern SVG_SPREADMETHOD_PAD = 1
 pattern SVG_SPREADMETHOD_REFLECT = 2
@@ -44,6 +61,16 @@
          (js_getGradientUnits (toSVGGradientElement self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGGradientElement.gradientUnits Mozilla SVGGradientElement.gradientUnits documentation> 
+getGradientUnitsUnsafe ::
+                       (MonadIO m, IsSVGGradientElement self, HasCallStack) =>
+                         self -> m SVGAnimatedEnumeration
+getGradientUnitsUnsafe self
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_getGradientUnits (toSVGGradientElement self)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGGradientElement.gradientUnits Mozilla SVGGradientElement.gradientUnits documentation> 
 getGradientUnitsUnchecked ::
                           (MonadIO m, IsSVGGradientElement self) =>
                             self -> m SVGAnimatedEnumeration
@@ -66,6 +93,16 @@
          (js_getGradientTransform (toSVGGradientElement self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGGradientElement.gradientTransform Mozilla SVGGradientElement.gradientTransform documentation> 
+getGradientTransformUnsafe ::
+                           (MonadIO m, IsSVGGradientElement self, HasCallStack) =>
+                             self -> m SVGAnimatedTransformList
+getGradientTransformUnsafe self
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_getGradientTransform (toSVGGradientElement self)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGGradientElement.gradientTransform Mozilla SVGGradientElement.gradientTransform documentation> 
 getGradientTransformUnchecked ::
                               (MonadIO m, IsSVGGradientElement self) =>
                                 self -> m SVGAnimatedTransformList
@@ -86,6 +123,16 @@
   = liftIO
       (nullableToMaybe <$>
          (js_getSpreadMethod (toSVGGradientElement self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGGradientElement.spreadMethod Mozilla SVGGradientElement.spreadMethod documentation> 
+getSpreadMethodUnsafe ::
+                      (MonadIO m, IsSVGGradientElement self, HasCallStack) =>
+                        self -> m SVGAnimatedEnumeration
+getSpreadMethodUnsafe self
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_getSpreadMethod (toSVGGradientElement self)))
+         >>= maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGGradientElement.spreadMethod Mozilla SVGGradientElement.spreadMethod documentation> 
 getSpreadMethodUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/SVGGraphicsElement.hs b/src/GHCJS/DOM/JSFFI/Generated/SVGGraphicsElement.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/SVGGraphicsElement.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/SVGGraphicsElement.hs
@@ -1,18 +1,27 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.SVGGraphicsElement
-       (js_getBBox, getBBox, getBBox_, getBBoxUnchecked, js_getCTM,
-        getCTM, getCTM_, getCTMUnchecked, js_getScreenCTM, getScreenCTM,
-        getScreenCTM_, getScreenCTMUnchecked, js_getTransformToElement,
+       (js_getBBox, getBBox, getBBox_, getBBoxUnsafe, getBBoxUnchecked,
+        js_getCTM, getCTM, getCTM_, getCTMUnsafe, getCTMUnchecked,
+        js_getScreenCTM, getScreenCTM, getScreenCTM_, getScreenCTMUnsafe,
+        getScreenCTMUnchecked, js_getTransformToElement,
         getTransformToElement, getTransformToElement_,
-        getTransformToElementUnchecked, js_getTransform, getTransform,
+        getTransformToElementUnsafe, getTransformToElementUnchecked,
+        js_getTransform, getTransform, getTransformUnsafe,
         getTransformUnchecked, js_getNearestViewportElement,
-        getNearestViewportElement, getNearestViewportElementUnchecked,
-        js_getFarthestViewportElement, getFarthestViewportElement,
-        getFarthestViewportElementUnchecked, SVGGraphicsElement,
-        castToSVGGraphicsElement, gTypeSVGGraphicsElement,
-        IsSVGGraphicsElement, toSVGGraphicsElement)
+        getNearestViewportElement, getNearestViewportElementUnsafe,
+        getNearestViewportElementUnchecked, js_getFarthestViewportElement,
+        getFarthestViewportElement, getFarthestViewportElementUnsafe,
+        getFarthestViewportElementUnchecked, SVGGraphicsElement(..),
+        gTypeSVGGraphicsElement, IsSVGGraphicsElement,
+        toSVGGraphicsElement)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -28,6 +37,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"getBBox\"]()" js_getBBox ::
         SVGGraphicsElement -> IO (Nullable SVGRect)
@@ -45,6 +64,15 @@
   = liftIO (void (js_getBBox (toSVGGraphicsElement self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGGraphicsElement.getBBox Mozilla SVGGraphicsElement.getBBox documentation> 
+getBBoxUnsafe ::
+              (MonadIO m, IsSVGGraphicsElement self, HasCallStack) =>
+                self -> m SVGRect
+getBBoxUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getBBox (toSVGGraphicsElement self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGGraphicsElement.getBBox Mozilla SVGGraphicsElement.getBBox documentation> 
 getBBoxUnchecked ::
                  (MonadIO m, IsSVGGraphicsElement self) => self -> m SVGRect
 getBBoxUnchecked self
@@ -69,6 +97,15 @@
   = liftIO (void (js_getCTM (toSVGGraphicsElement self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGGraphicsElement.getCTM Mozilla SVGGraphicsElement.getCTM documentation> 
+getCTMUnsafe ::
+             (MonadIO m, IsSVGGraphicsElement self, HasCallStack) =>
+               self -> m SVGMatrix
+getCTMUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getCTM (toSVGGraphicsElement self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGGraphicsElement.getCTM Mozilla SVGGraphicsElement.getCTM documentation> 
 getCTMUnchecked ::
                 (MonadIO m, IsSVGGraphicsElement self) => self -> m SVGMatrix
 getCTMUnchecked self
@@ -94,6 +131,16 @@
   = liftIO (void (js_getScreenCTM (toSVGGraphicsElement self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGGraphicsElement.getScreenCTM Mozilla SVGGraphicsElement.getScreenCTM documentation> 
+getScreenCTMUnsafe ::
+                   (MonadIO m, IsSVGGraphicsElement self, HasCallStack) =>
+                     self -> m SVGMatrix
+getScreenCTMUnsafe self
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_getScreenCTM (toSVGGraphicsElement self)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGGraphicsElement.getScreenCTM Mozilla SVGGraphicsElement.getScreenCTM documentation> 
 getScreenCTMUnchecked ::
                       (MonadIO m, IsSVGGraphicsElement self) => self -> m SVGMatrix
 getScreenCTMUnchecked self
@@ -127,6 +174,18 @@
             (maybeToNullable (fmap toSVGElement element))))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGGraphicsElement.getTransformToElement Mozilla SVGGraphicsElement.getTransformToElement documentation> 
+getTransformToElementUnsafe ::
+                            (MonadIO m, IsSVGGraphicsElement self, IsSVGElement element,
+                             HasCallStack) =>
+                              self -> Maybe element -> m SVGMatrix
+getTransformToElementUnsafe self element
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_getTransformToElement (toSVGGraphicsElement self)
+             (maybeToNullable (fmap toSVGElement element))))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGGraphicsElement.getTransformToElement Mozilla SVGGraphicsElement.getTransformToElement documentation> 
 getTransformToElementUnchecked ::
                                (MonadIO m, IsSVGGraphicsElement self, IsSVGElement element) =>
                                  self -> Maybe element -> m SVGMatrix
@@ -149,6 +208,16 @@
       (nullableToMaybe <$> (js_getTransform (toSVGGraphicsElement self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGGraphicsElement.transform Mozilla SVGGraphicsElement.transform documentation> 
+getTransformUnsafe ::
+                   (MonadIO m, IsSVGGraphicsElement self, HasCallStack) =>
+                     self -> m SVGAnimatedTransformList
+getTransformUnsafe self
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_getTransform (toSVGGraphicsElement self)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGGraphicsElement.transform Mozilla SVGGraphicsElement.transform documentation> 
 getTransformUnchecked ::
                       (MonadIO m, IsSVGGraphicsElement self) =>
                         self -> m SVGAnimatedTransformList
@@ -171,6 +240,16 @@
          (js_getNearestViewportElement (toSVGGraphicsElement self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGGraphicsElement.nearestViewportElement Mozilla SVGGraphicsElement.nearestViewportElement documentation> 
+getNearestViewportElementUnsafe ::
+                                (MonadIO m, IsSVGGraphicsElement self, HasCallStack) =>
+                                  self -> m SVGElement
+getNearestViewportElementUnsafe self
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_getNearestViewportElement (toSVGGraphicsElement self)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGGraphicsElement.nearestViewportElement Mozilla SVGGraphicsElement.nearestViewportElement documentation> 
 getNearestViewportElementUnchecked ::
                                    (MonadIO m, IsSVGGraphicsElement self) => self -> m SVGElement
 getNearestViewportElementUnchecked self
@@ -190,6 +269,16 @@
   = liftIO
       (nullableToMaybe <$>
          (js_getFarthestViewportElement (toSVGGraphicsElement self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGGraphicsElement.farthestViewportElement Mozilla SVGGraphicsElement.farthestViewportElement documentation> 
+getFarthestViewportElementUnsafe ::
+                                 (MonadIO m, IsSVGGraphicsElement self, HasCallStack) =>
+                                   self -> m SVGElement
+getFarthestViewportElementUnsafe self
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_getFarthestViewportElement (toSVGGraphicsElement self)))
+         >>= maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGGraphicsElement.farthestViewportElement Mozilla SVGGraphicsElement.farthestViewportElement documentation> 
 getFarthestViewportElementUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/SVGImageElement.hs b/src/GHCJS/DOM/JSFFI/Generated/SVGImageElement.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/SVGImageElement.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/SVGImageElement.hs
@@ -1,12 +1,20 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.SVGImageElement
-       (js_getX, getX, getXUnchecked, js_getY, getY, getYUnchecked,
-        js_getWidth, getWidth, getWidthUnchecked, js_getHeight, getHeight,
+       (js_getX, getX, getXUnsafe, getXUnchecked, js_getY, getY,
+        getYUnsafe, getYUnchecked, js_getWidth, getWidth, getWidthUnsafe,
+        getWidthUnchecked, js_getHeight, getHeight, getHeightUnsafe,
         getHeightUnchecked, js_getPreserveAspectRatio,
-        getPreserveAspectRatio, getPreserveAspectRatioUnchecked,
-        SVGImageElement, castToSVGImageElement, gTypeSVGImageElement)
+        getPreserveAspectRatio, getPreserveAspectRatioUnsafe,
+        getPreserveAspectRatioUnchecked, SVGImageElement(..),
+        gTypeSVGImageElement)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -22,6 +30,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"x\"]" js_getX ::
         SVGImageElement -> IO (Nullable SVGAnimatedLength)
@@ -32,6 +50,14 @@
 getX self = liftIO (nullableToMaybe <$> (js_getX (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGImageElement.x Mozilla SVGImageElement.x documentation> 
+getXUnsafe ::
+           (MonadIO m, HasCallStack) => SVGImageElement -> m SVGAnimatedLength
+getXUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getX (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGImageElement.x Mozilla SVGImageElement.x documentation> 
 getXUnchecked ::
               (MonadIO m) => SVGImageElement -> m SVGAnimatedLength
 getXUnchecked self
@@ -46,6 +72,14 @@
 getY self = liftIO (nullableToMaybe <$> (js_getY (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGImageElement.y Mozilla SVGImageElement.y documentation> 
+getYUnsafe ::
+           (MonadIO m, HasCallStack) => SVGImageElement -> m SVGAnimatedLength
+getYUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getY (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGImageElement.y Mozilla SVGImageElement.y documentation> 
 getYUnchecked ::
               (MonadIO m) => SVGImageElement -> m SVGAnimatedLength
 getYUnchecked self
@@ -60,6 +94,14 @@
 getWidth self = liftIO (nullableToMaybe <$> (js_getWidth (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGImageElement.width Mozilla SVGImageElement.width documentation> 
+getWidthUnsafe ::
+               (MonadIO m, HasCallStack) => SVGImageElement -> m SVGAnimatedLength
+getWidthUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getWidth (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGImageElement.width Mozilla SVGImageElement.width documentation> 
 getWidthUnchecked ::
                   (MonadIO m) => SVGImageElement -> m SVGAnimatedLength
 getWidthUnchecked self
@@ -74,6 +116,14 @@
 getHeight self = liftIO (nullableToMaybe <$> (js_getHeight (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGImageElement.height Mozilla SVGImageElement.height documentation> 
+getHeightUnsafe ::
+                (MonadIO m, HasCallStack) => SVGImageElement -> m SVGAnimatedLength
+getHeightUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getHeight (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGImageElement.height Mozilla SVGImageElement.height documentation> 
 getHeightUnchecked ::
                    (MonadIO m) => SVGImageElement -> m SVGAnimatedLength
 getHeightUnchecked self
@@ -89,6 +139,15 @@
                          SVGImageElement -> m (Maybe SVGAnimatedPreserveAspectRatio)
 getPreserveAspectRatio self
   = liftIO (nullableToMaybe <$> (js_getPreserveAspectRatio (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGImageElement.preserveAspectRatio Mozilla SVGImageElement.preserveAspectRatio documentation> 
+getPreserveAspectRatioUnsafe ::
+                             (MonadIO m, HasCallStack) =>
+                               SVGImageElement -> m SVGAnimatedPreserveAspectRatio
+getPreserveAspectRatioUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getPreserveAspectRatio (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGImageElement.preserveAspectRatio Mozilla SVGImageElement.preserveAspectRatio documentation> 
 getPreserveAspectRatioUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/SVGLength.hs b/src/GHCJS/DOM/JSFFI/Generated/SVGLength.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/SVGLength.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/SVGLength.hs
@@ -1,4 +1,9 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.SVGLength
        (js_newValueSpecifiedUnits, newValueSpecifiedUnits,
         js_convertToSpecifiedUnits, convertToSpecifiedUnits,
@@ -12,10 +17,11 @@
         js_setValueInSpecifiedUnits, setValueInSpecifiedUnits,
         js_getValueInSpecifiedUnits, getValueInSpecifiedUnits,
         js_setValueAsString, setValueAsString, js_getValueAsString,
-        getValueAsString, getValueAsStringUnchecked, SVGLength,
-        castToSVGLength, gTypeSVGLength)
+        getValueAsString, getValueAsStringUnsafe,
+        getValueAsStringUnchecked, SVGLength(..), gTypeSVGLength)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -31,6 +37,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe
         "$1[\"newValueSpecifiedUnits\"]($2,\n$3)" js_newValueSpecifiedUnits
@@ -119,6 +135,15 @@
                  (MonadIO m, FromJSString result) => SVGLength -> m (Maybe result)
 getValueAsString self
   = liftIO (fromMaybeJSString <$> (js_getValueAsString (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGLength.valueAsString Mozilla SVGLength.valueAsString documentation> 
+getValueAsStringUnsafe ::
+                       (MonadIO m, HasCallStack, FromJSString result) =>
+                         SVGLength -> m result
+getValueAsStringUnsafe self
+  = liftIO
+      ((fromMaybeJSString <$> (js_getValueAsString (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGLength.valueAsString Mozilla SVGLength.valueAsString documentation> 
 getValueAsStringUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/SVGLengthList.hs b/src/GHCJS/DOM/JSFFI/Generated/SVGLengthList.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/SVGLengthList.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/SVGLengthList.hs
@@ -1,16 +1,23 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.SVGLengthList
        (js_clear, clear, js_initialize, initialize, initialize_,
-        initializeUnchecked, js_getItem, getItem, getItem_,
-        getItemUnchecked, js_insertItemBefore, insertItemBefore,
-        insertItemBefore_, insertItemBeforeUnchecked, js_replaceItem,
-        replaceItem, replaceItem_, replaceItemUnchecked, js_removeItem,
-        removeItem, removeItem_, removeItemUnchecked, js_appendItem,
-        appendItem, appendItem_, appendItemUnchecked, js_getNumberOfItems,
-        getNumberOfItems, SVGLengthList, castToSVGLengthList,
-        gTypeSVGLengthList)
+        initializeUnsafe, initializeUnchecked, js_getItem, getItem,
+        getItem_, getItemUnsafe, getItemUnchecked, js_insertItemBefore,
+        insertItemBefore, insertItemBefore_, insertItemBeforeUnsafe,
+        insertItemBeforeUnchecked, js_replaceItem, replaceItem,
+        replaceItem_, replaceItemUnsafe, replaceItemUnchecked,
+        js_removeItem, removeItem, removeItem_, removeItemUnsafe,
+        removeItemUnchecked, js_appendItem, appendItem, appendItem_,
+        appendItemUnsafe, appendItemUnchecked, js_getNumberOfItems,
+        getNumberOfItems, SVGLengthList(..), gTypeSVGLengthList)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -26,6 +33,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"clear\"]()" js_clear ::
         SVGLengthList -> IO ()
@@ -53,6 +70,16 @@
   = liftIO (void (js_initialize (self) (maybeToNullable item)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGLengthList.initialize Mozilla SVGLengthList.initialize documentation> 
+initializeUnsafe ::
+                 (MonadIO m, HasCallStack) =>
+                   SVGLengthList -> Maybe SVGLength -> m SVGLength
+initializeUnsafe self item
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_initialize (self) (maybeToNullable item)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGLengthList.initialize Mozilla SVGLengthList.initialize documentation> 
 initializeUnchecked ::
                     (MonadIO m) => SVGLengthList -> Maybe SVGLength -> m SVGLength
 initializeUnchecked self item
@@ -74,6 +101,14 @@
 getItem_ self index = liftIO (void (js_getItem (self) index))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGLengthList.getItem Mozilla SVGLengthList.getItem documentation> 
+getItemUnsafe ::
+              (MonadIO m, HasCallStack) => SVGLengthList -> Word -> m SVGLength
+getItemUnsafe self index
+  = liftIO
+      ((nullableToMaybe <$> (js_getItem (self) index)) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGLengthList.getItem Mozilla SVGLengthList.getItem documentation> 
 getItemUnchecked ::
                  (MonadIO m) => SVGLengthList -> Word -> m SVGLength
 getItemUnchecked self index
@@ -101,6 +136,16 @@
       (void (js_insertItemBefore (self) (maybeToNullable item) index))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGLengthList.insertItemBefore Mozilla SVGLengthList.insertItemBefore documentation> 
+insertItemBeforeUnsafe ::
+                       (MonadIO m, HasCallStack) =>
+                         SVGLengthList -> Maybe SVGLength -> Word -> m SVGLength
+insertItemBeforeUnsafe self item index
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_insertItemBefore (self) (maybeToNullable item) index))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGLengthList.insertItemBefore Mozilla SVGLengthList.insertItemBefore documentation> 
 insertItemBeforeUnchecked ::
                           (MonadIO m) =>
                             SVGLengthList -> Maybe SVGLength -> Word -> m SVGLength
@@ -131,6 +176,16 @@
       (void (js_replaceItem (self) (maybeToNullable item) index))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGLengthList.replaceItem Mozilla SVGLengthList.replaceItem documentation> 
+replaceItemUnsafe ::
+                  (MonadIO m, HasCallStack) =>
+                    SVGLengthList -> Maybe SVGLength -> Word -> m SVGLength
+replaceItemUnsafe self item index
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_replaceItem (self) (maybeToNullable item) index))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGLengthList.replaceItem Mozilla SVGLengthList.replaceItem documentation> 
 replaceItemUnchecked ::
                      (MonadIO m) =>
                        SVGLengthList -> Maybe SVGLength -> Word -> m SVGLength
@@ -153,6 +208,14 @@
 removeItem_ self index = liftIO (void (js_removeItem (self) index))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGLengthList.removeItem Mozilla SVGLengthList.removeItem documentation> 
+removeItemUnsafe ::
+                 (MonadIO m, HasCallStack) => SVGLengthList -> Word -> m SVGLength
+removeItemUnsafe self index
+  = liftIO
+      ((nullableToMaybe <$> (js_removeItem (self) index)) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGLengthList.removeItem Mozilla SVGLengthList.removeItem documentation> 
 removeItemUnchecked ::
                     (MonadIO m) => SVGLengthList -> Word -> m SVGLength
 removeItemUnchecked self index
@@ -176,6 +239,16 @@
             (MonadIO m) => SVGLengthList -> Maybe SVGLength -> m ()
 appendItem_ self item
   = liftIO (void (js_appendItem (self) (maybeToNullable item)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGLengthList.appendItem Mozilla SVGLengthList.appendItem documentation> 
+appendItemUnsafe ::
+                 (MonadIO m, HasCallStack) =>
+                   SVGLengthList -> Maybe SVGLength -> m SVGLength
+appendItemUnsafe self item
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_appendItem (self) (maybeToNullable item)))
+         >>= maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGLengthList.appendItem Mozilla SVGLengthList.appendItem documentation> 
 appendItemUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/SVGLineElement.hs b/src/GHCJS/DOM/JSFFI/Generated/SVGLineElement.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/SVGLineElement.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/SVGLineElement.hs
@@ -1,10 +1,17 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.SVGLineElement
-       (js_getX1, getX1, getX1Unchecked, js_getY1, getY1, getY1Unchecked,
-        js_getX2, getX2, getX2Unchecked, js_getY2, getY2, getY2Unchecked,
-        SVGLineElement, castToSVGLineElement, gTypeSVGLineElement)
+       (js_getX1, getX1, getX1Unsafe, getX1Unchecked, js_getY1, getY1,
+        getY1Unsafe, getY1Unchecked, js_getX2, getX2, getX2Unsafe,
+        getX2Unchecked, js_getY2, getY2, getY2Unsafe, getY2Unchecked,
+        SVGLineElement(..), gTypeSVGLineElement)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -20,6 +27,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"x1\"]" js_getX1 ::
         SVGLineElement -> IO (Nullable SVGAnimatedLength)
@@ -30,6 +47,14 @@
 getX1 self = liftIO (nullableToMaybe <$> (js_getX1 (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGLineElement.x1 Mozilla SVGLineElement.x1 documentation> 
+getX1Unsafe ::
+            (MonadIO m, HasCallStack) => SVGLineElement -> m SVGAnimatedLength
+getX1Unsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getX1 (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGLineElement.x1 Mozilla SVGLineElement.x1 documentation> 
 getX1Unchecked ::
                (MonadIO m) => SVGLineElement -> m SVGAnimatedLength
 getX1Unchecked self
@@ -44,6 +69,14 @@
 getY1 self = liftIO (nullableToMaybe <$> (js_getY1 (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGLineElement.y1 Mozilla SVGLineElement.y1 documentation> 
+getY1Unsafe ::
+            (MonadIO m, HasCallStack) => SVGLineElement -> m SVGAnimatedLength
+getY1Unsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getY1 (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGLineElement.y1 Mozilla SVGLineElement.y1 documentation> 
 getY1Unchecked ::
                (MonadIO m) => SVGLineElement -> m SVGAnimatedLength
 getY1Unchecked self
@@ -58,6 +91,14 @@
 getX2 self = liftIO (nullableToMaybe <$> (js_getX2 (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGLineElement.x2 Mozilla SVGLineElement.x2 documentation> 
+getX2Unsafe ::
+            (MonadIO m, HasCallStack) => SVGLineElement -> m SVGAnimatedLength
+getX2Unsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getX2 (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGLineElement.x2 Mozilla SVGLineElement.x2 documentation> 
 getX2Unchecked ::
                (MonadIO m) => SVGLineElement -> m SVGAnimatedLength
 getX2Unchecked self
@@ -70,6 +111,14 @@
 getY2 ::
       (MonadIO m) => SVGLineElement -> m (Maybe SVGAnimatedLength)
 getY2 self = liftIO (nullableToMaybe <$> (js_getY2 (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGLineElement.y2 Mozilla SVGLineElement.y2 documentation> 
+getY2Unsafe ::
+            (MonadIO m, HasCallStack) => SVGLineElement -> m SVGAnimatedLength
+getY2Unsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getY2 (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGLineElement.y2 Mozilla SVGLineElement.y2 documentation> 
 getY2Unchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/SVGLinearGradientElement.hs b/src/GHCJS/DOM/JSFFI/Generated/SVGLinearGradientElement.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/SVGLinearGradientElement.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/SVGLinearGradientElement.hs
@@ -1,11 +1,17 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.SVGLinearGradientElement
-       (js_getX1, getX1, getX1Unchecked, js_getY1, getY1, getY1Unchecked,
-        js_getX2, getX2, getX2Unchecked, js_getY2, getY2, getY2Unchecked,
-        SVGLinearGradientElement, castToSVGLinearGradientElement,
-        gTypeSVGLinearGradientElement)
+       (js_getX1, getX1, getX1Unsafe, getX1Unchecked, js_getY1, getY1,
+        getY1Unsafe, getY1Unchecked, js_getX2, getX2, getX2Unsafe,
+        getX2Unchecked, js_getY2, getY2, getY2Unsafe, getY2Unchecked,
+        SVGLinearGradientElement(..), gTypeSVGLinearGradientElement)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -21,6 +27,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"x1\"]" js_getX1 ::
         SVGLinearGradientElement -> IO (Nullable SVGAnimatedLength)
@@ -32,6 +48,15 @@
 getX1 self = liftIO (nullableToMaybe <$> (js_getX1 (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGLinearGradientElement.x1 Mozilla SVGLinearGradientElement.x1 documentation> 
+getX1Unsafe ::
+            (MonadIO m, HasCallStack) =>
+              SVGLinearGradientElement -> m SVGAnimatedLength
+getX1Unsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getX1 (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGLinearGradientElement.x1 Mozilla SVGLinearGradientElement.x1 documentation> 
 getX1Unchecked ::
                (MonadIO m) => SVGLinearGradientElement -> m SVGAnimatedLength
 getX1Unchecked self
@@ -47,6 +72,15 @@
 getY1 self = liftIO (nullableToMaybe <$> (js_getY1 (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGLinearGradientElement.y1 Mozilla SVGLinearGradientElement.y1 documentation> 
+getY1Unsafe ::
+            (MonadIO m, HasCallStack) =>
+              SVGLinearGradientElement -> m SVGAnimatedLength
+getY1Unsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getY1 (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGLinearGradientElement.y1 Mozilla SVGLinearGradientElement.y1 documentation> 
 getY1Unchecked ::
                (MonadIO m) => SVGLinearGradientElement -> m SVGAnimatedLength
 getY1Unchecked self
@@ -62,6 +96,15 @@
 getX2 self = liftIO (nullableToMaybe <$> (js_getX2 (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGLinearGradientElement.x2 Mozilla SVGLinearGradientElement.x2 documentation> 
+getX2Unsafe ::
+            (MonadIO m, HasCallStack) =>
+              SVGLinearGradientElement -> m SVGAnimatedLength
+getX2Unsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getX2 (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGLinearGradientElement.x2 Mozilla SVGLinearGradientElement.x2 documentation> 
 getX2Unchecked ::
                (MonadIO m) => SVGLinearGradientElement -> m SVGAnimatedLength
 getX2Unchecked self
@@ -75,6 +118,15 @@
       (MonadIO m) =>
         SVGLinearGradientElement -> m (Maybe SVGAnimatedLength)
 getY2 self = liftIO (nullableToMaybe <$> (js_getY2 (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGLinearGradientElement.y2 Mozilla SVGLinearGradientElement.y2 documentation> 
+getY2Unsafe ::
+            (MonadIO m, HasCallStack) =>
+              SVGLinearGradientElement -> m SVGAnimatedLength
+getY2Unsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getY2 (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGLinearGradientElement.y2 Mozilla SVGLinearGradientElement.y2 documentation> 
 getY2Unchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/SVGMarkerElement.hs b/src/GHCJS/DOM/JSFFI/Generated/SVGMarkerElement.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/SVGMarkerElement.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/SVGMarkerElement.hs
@@ -1,4 +1,9 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.SVGMarkerElement
        (js_setOrientToAuto, setOrientToAuto, js_setOrientToAngle,
         setOrientToAngle, pattern SVG_MARKERUNITS_UNKNOWN,
@@ -6,15 +11,18 @@
         pattern SVG_MARKERUNITS_STROKEWIDTH,
         pattern SVG_MARKER_ORIENT_UNKNOWN, pattern SVG_MARKER_ORIENT_AUTO,
         pattern SVG_MARKER_ORIENT_ANGLE, js_getRefX, getRefX,
-        getRefXUnchecked, js_getRefY, getRefY, getRefYUnchecked,
-        js_getMarkerUnits, getMarkerUnits, getMarkerUnitsUnchecked,
-        js_getMarkerWidth, getMarkerWidth, getMarkerWidthUnchecked,
-        js_getMarkerHeight, getMarkerHeight, getMarkerHeightUnchecked,
-        js_getOrientType, getOrientType, getOrientTypeUnchecked,
-        js_getOrientAngle, getOrientAngle, getOrientAngleUnchecked,
-        SVGMarkerElement, castToSVGMarkerElement, gTypeSVGMarkerElement)
+        getRefXUnsafe, getRefXUnchecked, js_getRefY, getRefY,
+        getRefYUnsafe, getRefYUnchecked, js_getMarkerUnits, getMarkerUnits,
+        getMarkerUnitsUnsafe, getMarkerUnitsUnchecked, js_getMarkerWidth,
+        getMarkerWidth, getMarkerWidthUnsafe, getMarkerWidthUnchecked,
+        js_getMarkerHeight, getMarkerHeight, getMarkerHeightUnsafe,
+        getMarkerHeightUnchecked, js_getOrientType, getOrientType,
+        getOrientTypeUnsafe, getOrientTypeUnchecked, js_getOrientAngle,
+        getOrientAngle, getOrientAngleUnsafe, getOrientAngleUnchecked,
+        SVGMarkerElement(..), gTypeSVGMarkerElement)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -30,6 +38,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"setOrientToAuto\"]()"
         js_setOrientToAuto :: SVGMarkerElement -> IO ()
@@ -63,6 +81,15 @@
 getRefX self = liftIO (nullableToMaybe <$> (js_getRefX (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGMarkerElement.refX Mozilla SVGMarkerElement.refX documentation> 
+getRefXUnsafe ::
+              (MonadIO m, HasCallStack) =>
+                SVGMarkerElement -> m SVGAnimatedLength
+getRefXUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getRefX (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGMarkerElement.refX Mozilla SVGMarkerElement.refX documentation> 
 getRefXUnchecked ::
                  (MonadIO m) => SVGMarkerElement -> m SVGAnimatedLength
 getRefXUnchecked self
@@ -77,6 +104,15 @@
 getRefY self = liftIO (nullableToMaybe <$> (js_getRefY (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGMarkerElement.refY Mozilla SVGMarkerElement.refY documentation> 
+getRefYUnsafe ::
+              (MonadIO m, HasCallStack) =>
+                SVGMarkerElement -> m SVGAnimatedLength
+getRefYUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getRefY (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGMarkerElement.refY Mozilla SVGMarkerElement.refY documentation> 
 getRefYUnchecked ::
                  (MonadIO m) => SVGMarkerElement -> m SVGAnimatedLength
 getRefYUnchecked self
@@ -93,6 +129,15 @@
   = liftIO (nullableToMaybe <$> (js_getMarkerUnits (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGMarkerElement.markerUnits Mozilla SVGMarkerElement.markerUnits documentation> 
+getMarkerUnitsUnsafe ::
+                     (MonadIO m, HasCallStack) =>
+                       SVGMarkerElement -> m SVGAnimatedEnumeration
+getMarkerUnitsUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getMarkerUnits (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGMarkerElement.markerUnits Mozilla SVGMarkerElement.markerUnits documentation> 
 getMarkerUnitsUnchecked ::
                         (MonadIO m) => SVGMarkerElement -> m SVGAnimatedEnumeration
 getMarkerUnitsUnchecked self
@@ -110,6 +155,15 @@
   = liftIO (nullableToMaybe <$> (js_getMarkerWidth (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGMarkerElement.markerWidth Mozilla SVGMarkerElement.markerWidth documentation> 
+getMarkerWidthUnsafe ::
+                     (MonadIO m, HasCallStack) =>
+                       SVGMarkerElement -> m SVGAnimatedLength
+getMarkerWidthUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getMarkerWidth (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGMarkerElement.markerWidth Mozilla SVGMarkerElement.markerWidth documentation> 
 getMarkerWidthUnchecked ::
                         (MonadIO m) => SVGMarkerElement -> m SVGAnimatedLength
 getMarkerWidthUnchecked self
@@ -127,6 +181,15 @@
   = liftIO (nullableToMaybe <$> (js_getMarkerHeight (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGMarkerElement.markerHeight Mozilla SVGMarkerElement.markerHeight documentation> 
+getMarkerHeightUnsafe ::
+                      (MonadIO m, HasCallStack) =>
+                        SVGMarkerElement -> m SVGAnimatedLength
+getMarkerHeightUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getMarkerHeight (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGMarkerElement.markerHeight Mozilla SVGMarkerElement.markerHeight documentation> 
 getMarkerHeightUnchecked ::
                          (MonadIO m) => SVGMarkerElement -> m SVGAnimatedLength
 getMarkerHeightUnchecked self
@@ -144,6 +207,15 @@
   = liftIO (nullableToMaybe <$> (js_getOrientType (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGMarkerElement.orientType Mozilla SVGMarkerElement.orientType documentation> 
+getOrientTypeUnsafe ::
+                    (MonadIO m, HasCallStack) =>
+                      SVGMarkerElement -> m SVGAnimatedEnumeration
+getOrientTypeUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getOrientType (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGMarkerElement.orientType Mozilla SVGMarkerElement.orientType documentation> 
 getOrientTypeUnchecked ::
                        (MonadIO m) => SVGMarkerElement -> m SVGAnimatedEnumeration
 getOrientTypeUnchecked self
@@ -158,6 +230,14 @@
                (MonadIO m) => SVGMarkerElement -> m (Maybe SVGAnimatedAngle)
 getOrientAngle self
   = liftIO (nullableToMaybe <$> (js_getOrientAngle (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGMarkerElement.orientAngle Mozilla SVGMarkerElement.orientAngle documentation> 
+getOrientAngleUnsafe ::
+                     (MonadIO m, HasCallStack) => SVGMarkerElement -> m SVGAnimatedAngle
+getOrientAngleUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getOrientAngle (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGMarkerElement.orientAngle Mozilla SVGMarkerElement.orientAngle documentation> 
 getOrientAngleUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/SVGMaskElement.hs b/src/GHCJS/DOM/JSFFI/Generated/SVGMaskElement.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/SVGMaskElement.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/SVGMaskElement.hs
@@ -1,13 +1,20 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.SVGMaskElement
-       (js_getMaskUnits, getMaskUnits, getMaskUnitsUnchecked,
-        js_getMaskContentUnits, getMaskContentUnits,
-        getMaskContentUnitsUnchecked, js_getX, getX, getXUnchecked,
-        js_getY, getY, getYUnchecked, js_getWidth, getWidth,
-        getWidthUnchecked, js_getHeight, getHeight, getHeightUnchecked,
-        SVGMaskElement, castToSVGMaskElement, gTypeSVGMaskElement)
+       (js_getMaskUnits, getMaskUnits, getMaskUnitsUnsafe,
+        getMaskUnitsUnchecked, js_getMaskContentUnits, getMaskContentUnits,
+        getMaskContentUnitsUnsafe, getMaskContentUnitsUnchecked, js_getX,
+        getX, getXUnsafe, getXUnchecked, js_getY, getY, getYUnsafe,
+        getYUnchecked, js_getWidth, getWidth, getWidthUnsafe,
+        getWidthUnchecked, js_getHeight, getHeight, getHeightUnsafe,
+        getHeightUnchecked, SVGMaskElement(..), gTypeSVGMaskElement)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -23,6 +30,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"maskUnits\"]"
         js_getMaskUnits ::
@@ -35,6 +52,15 @@
   = liftIO (nullableToMaybe <$> (js_getMaskUnits (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGMaskElement.maskUnits Mozilla SVGMaskElement.maskUnits documentation> 
+getMaskUnitsUnsafe ::
+                   (MonadIO m, HasCallStack) =>
+                     SVGMaskElement -> m SVGAnimatedEnumeration
+getMaskUnitsUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getMaskUnits (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGMaskElement.maskUnits Mozilla SVGMaskElement.maskUnits documentation> 
 getMaskUnitsUnchecked ::
                       (MonadIO m) => SVGMaskElement -> m SVGAnimatedEnumeration
 getMaskUnitsUnchecked self
@@ -51,6 +77,15 @@
   = liftIO (nullableToMaybe <$> (js_getMaskContentUnits (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGMaskElement.maskContentUnits Mozilla SVGMaskElement.maskContentUnits documentation> 
+getMaskContentUnitsUnsafe ::
+                          (MonadIO m, HasCallStack) =>
+                            SVGMaskElement -> m SVGAnimatedEnumeration
+getMaskContentUnitsUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getMaskContentUnits (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGMaskElement.maskContentUnits Mozilla SVGMaskElement.maskContentUnits documentation> 
 getMaskContentUnitsUnchecked ::
                              (MonadIO m) => SVGMaskElement -> m SVGAnimatedEnumeration
 getMaskContentUnitsUnchecked self
@@ -66,6 +101,14 @@
 getX self = liftIO (nullableToMaybe <$> (js_getX (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGMaskElement.x Mozilla SVGMaskElement.x documentation> 
+getXUnsafe ::
+           (MonadIO m, HasCallStack) => SVGMaskElement -> m SVGAnimatedLength
+getXUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getX (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGMaskElement.x Mozilla SVGMaskElement.x documentation> 
 getXUnchecked ::
               (MonadIO m) => SVGMaskElement -> m SVGAnimatedLength
 getXUnchecked self
@@ -80,6 +123,14 @@
 getY self = liftIO (nullableToMaybe <$> (js_getY (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGMaskElement.y Mozilla SVGMaskElement.y documentation> 
+getYUnsafe ::
+           (MonadIO m, HasCallStack) => SVGMaskElement -> m SVGAnimatedLength
+getYUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getY (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGMaskElement.y Mozilla SVGMaskElement.y documentation> 
 getYUnchecked ::
               (MonadIO m) => SVGMaskElement -> m SVGAnimatedLength
 getYUnchecked self
@@ -94,6 +145,14 @@
 getWidth self = liftIO (nullableToMaybe <$> (js_getWidth (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGMaskElement.width Mozilla SVGMaskElement.width documentation> 
+getWidthUnsafe ::
+               (MonadIO m, HasCallStack) => SVGMaskElement -> m SVGAnimatedLength
+getWidthUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getWidth (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGMaskElement.width Mozilla SVGMaskElement.width documentation> 
 getWidthUnchecked ::
                   (MonadIO m) => SVGMaskElement -> m SVGAnimatedLength
 getWidthUnchecked self
@@ -106,6 +165,14 @@
 getHeight ::
           (MonadIO m) => SVGMaskElement -> m (Maybe SVGAnimatedLength)
 getHeight self = liftIO (nullableToMaybe <$> (js_getHeight (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGMaskElement.height Mozilla SVGMaskElement.height documentation> 
+getHeightUnsafe ::
+                (MonadIO m, HasCallStack) => SVGMaskElement -> m SVGAnimatedLength
+getHeightUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getHeight (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGMaskElement.height Mozilla SVGMaskElement.height documentation> 
 getHeightUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/SVGMatrix.hs b/src/GHCJS/DOM/JSFFI/Generated/SVGMatrix.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/SVGMatrix.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/SVGMatrix.hs
@@ -1,20 +1,29 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.SVGMatrix
-       (js_multiply, multiply, multiply_, multiplyUnchecked, js_inverse,
-        inverse, inverse_, inverseUnchecked, js_translate, translate,
-        translate_, translateUnchecked, js_scale, scale, scale_,
-        scaleUnchecked, js_scaleNonUniform, scaleNonUniform,
-        scaleNonUniform_, scaleNonUniformUnchecked, js_rotate, rotate,
-        rotate_, rotateUnchecked, js_rotateFromVector, rotateFromVector,
-        rotateFromVector_, rotateFromVectorUnchecked, js_flipX, flipX,
-        flipX_, flipXUnchecked, js_flipY, flipY, flipY_, flipYUnchecked,
-        js_skewX, skewX, skewX_, skewXUnchecked, js_skewY, skewY, skewY_,
+       (js_multiply, multiply, multiply_, multiplyUnsafe,
+        multiplyUnchecked, js_inverse, inverse, inverse_, inverseUnsafe,
+        inverseUnchecked, js_translate, translate, translate_,
+        translateUnsafe, translateUnchecked, js_scale, scale, scale_,
+        scaleUnsafe, scaleUnchecked, js_scaleNonUniform, scaleNonUniform,
+        scaleNonUniform_, scaleNonUniformUnsafe, scaleNonUniformUnchecked,
+        js_rotate, rotate, rotate_, rotateUnsafe, rotateUnchecked,
+        js_rotateFromVector, rotateFromVector, rotateFromVector_,
+        rotateFromVectorUnsafe, rotateFromVectorUnchecked, js_flipX, flipX,
+        flipX_, flipXUnsafe, flipXUnchecked, js_flipY, flipY, flipY_,
+        flipYUnsafe, flipYUnchecked, js_skewX, skewX, skewX_, skewXUnsafe,
+        skewXUnchecked, js_skewY, skewY, skewY_, skewYUnsafe,
         skewYUnchecked, js_setA, setA, js_getA, getA, js_setB, setB,
         js_getB, getB, js_setC, setC, js_getC, getC, js_setD, setD,
         js_getD, getD, js_setE, setE, js_getE, getE, js_setF, setF,
-        js_getF, getF, SVGMatrix, castToSVGMatrix, gTypeSVGMatrix)
+        js_getF, getF, SVGMatrix(..), gTypeSVGMatrix)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -30,6 +39,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"multiply\"]($2)" js_multiply
         :: SVGMatrix -> Nullable SVGMatrix -> IO (Nullable SVGMatrix)
@@ -48,6 +67,16 @@
   = liftIO (void (js_multiply (self) (maybeToNullable secondMatrix)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGMatrix.multiply Mozilla SVGMatrix.multiply documentation> 
+multiplyUnsafe ::
+               (MonadIO m, HasCallStack) =>
+                 SVGMatrix -> Maybe SVGMatrix -> m SVGMatrix
+multiplyUnsafe self secondMatrix
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_multiply (self) (maybeToNullable secondMatrix)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGMatrix.multiply Mozilla SVGMatrix.multiply documentation> 
 multiplyUnchecked ::
                   (MonadIO m) => SVGMatrix -> Maybe SVGMatrix -> m SVGMatrix
 multiplyUnchecked self secondMatrix
@@ -67,6 +96,14 @@
 inverse_ self = liftIO (void (js_inverse (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGMatrix.inverse Mozilla SVGMatrix.inverse documentation> 
+inverseUnsafe ::
+              (MonadIO m, HasCallStack) => SVGMatrix -> m SVGMatrix
+inverseUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_inverse (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGMatrix.inverse Mozilla SVGMatrix.inverse documentation> 
 inverseUnchecked :: (MonadIO m) => SVGMatrix -> m SVGMatrix
 inverseUnchecked self
   = liftIO (fromJust . nullableToMaybe <$> (js_inverse (self)))
@@ -86,6 +123,15 @@
 translate_ self x y = liftIO (void (js_translate (self) x y))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGMatrix.translate Mozilla SVGMatrix.translate documentation> 
+translateUnsafe ::
+                (MonadIO m, HasCallStack) =>
+                  SVGMatrix -> Float -> Float -> m SVGMatrix
+translateUnsafe self x y
+  = liftIO
+      ((nullableToMaybe <$> (js_translate (self) x y)) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGMatrix.translate Mozilla SVGMatrix.translate documentation> 
 translateUnchecked ::
                    (MonadIO m) => SVGMatrix -> Float -> Float -> m SVGMatrix
 translateUnchecked self x y
@@ -105,6 +151,14 @@
   = liftIO (void (js_scale (self) scaleFactor))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGMatrix.scale Mozilla SVGMatrix.scale documentation> 
+scaleUnsafe ::
+            (MonadIO m, HasCallStack) => SVGMatrix -> Float -> m SVGMatrix
+scaleUnsafe self scaleFactor
+  = liftIO
+      ((nullableToMaybe <$> (js_scale (self) scaleFactor)) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGMatrix.scale Mozilla SVGMatrix.scale documentation> 
 scaleUnchecked :: (MonadIO m) => SVGMatrix -> Float -> m SVGMatrix
 scaleUnchecked self scaleFactor
   = liftIO
@@ -130,6 +184,16 @@
       (void (js_scaleNonUniform (self) scaleFactorX scaleFactorY))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGMatrix.scaleNonUniform Mozilla SVGMatrix.scaleNonUniform documentation> 
+scaleNonUniformUnsafe ::
+                      (MonadIO m, HasCallStack) =>
+                        SVGMatrix -> Float -> Float -> m SVGMatrix
+scaleNonUniformUnsafe self scaleFactorX scaleFactorY
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_scaleNonUniform (self) scaleFactorX scaleFactorY))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGMatrix.scaleNonUniform Mozilla SVGMatrix.scaleNonUniform documentation> 
 scaleNonUniformUnchecked ::
                          (MonadIO m) => SVGMatrix -> Float -> Float -> m SVGMatrix
 scaleNonUniformUnchecked self scaleFactorX scaleFactorY
@@ -150,6 +214,14 @@
 rotate_ self angle = liftIO (void (js_rotate (self) angle))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGMatrix.rotate Mozilla SVGMatrix.rotate documentation> 
+rotateUnsafe ::
+             (MonadIO m, HasCallStack) => SVGMatrix -> Float -> m SVGMatrix
+rotateUnsafe self angle
+  = liftIO
+      ((nullableToMaybe <$> (js_rotate (self) angle)) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGMatrix.rotate Mozilla SVGMatrix.rotate documentation> 
 rotateUnchecked :: (MonadIO m) => SVGMatrix -> Float -> m SVGMatrix
 rotateUnchecked self angle
   = liftIO (fromJust . nullableToMaybe <$> (js_rotate (self) angle))
@@ -171,6 +243,15 @@
   = liftIO (void (js_rotateFromVector (self) x y))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGMatrix.rotateFromVector Mozilla SVGMatrix.rotateFromVector documentation> 
+rotateFromVectorUnsafe ::
+                       (MonadIO m, HasCallStack) =>
+                         SVGMatrix -> Float -> Float -> m SVGMatrix
+rotateFromVectorUnsafe self x y
+  = liftIO
+      ((nullableToMaybe <$> (js_rotateFromVector (self) x y)) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGMatrix.rotateFromVector Mozilla SVGMatrix.rotateFromVector documentation> 
 rotateFromVectorUnchecked ::
                           (MonadIO m) => SVGMatrix -> Float -> Float -> m SVGMatrix
 rotateFromVectorUnchecked self x y
@@ -189,6 +270,14 @@
 flipX_ self = liftIO (void (js_flipX (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGMatrix.flipX Mozilla SVGMatrix.flipX documentation> 
+flipXUnsafe ::
+            (MonadIO m, HasCallStack) => SVGMatrix -> m SVGMatrix
+flipXUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_flipX (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGMatrix.flipX Mozilla SVGMatrix.flipX documentation> 
 flipXUnchecked :: (MonadIO m) => SVGMatrix -> m SVGMatrix
 flipXUnchecked self
   = liftIO (fromJust . nullableToMaybe <$> (js_flipX (self)))
@@ -205,6 +294,14 @@
 flipY_ self = liftIO (void (js_flipY (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGMatrix.flipY Mozilla SVGMatrix.flipY documentation> 
+flipYUnsafe ::
+            (MonadIO m, HasCallStack) => SVGMatrix -> m SVGMatrix
+flipYUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_flipY (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGMatrix.flipY Mozilla SVGMatrix.flipY documentation> 
 flipYUnchecked :: (MonadIO m) => SVGMatrix -> m SVGMatrix
 flipYUnchecked self
   = liftIO (fromJust . nullableToMaybe <$> (js_flipY (self)))
@@ -222,6 +319,14 @@
 skewX_ self angle = liftIO (void (js_skewX (self) angle))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGMatrix.skewX Mozilla SVGMatrix.skewX documentation> 
+skewXUnsafe ::
+            (MonadIO m, HasCallStack) => SVGMatrix -> Float -> m SVGMatrix
+skewXUnsafe self angle
+  = liftIO
+      ((nullableToMaybe <$> (js_skewX (self) angle)) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGMatrix.skewX Mozilla SVGMatrix.skewX documentation> 
 skewXUnchecked :: (MonadIO m) => SVGMatrix -> Float -> m SVGMatrix
 skewXUnchecked self angle
   = liftIO (fromJust . nullableToMaybe <$> (js_skewX (self) angle))
@@ -237,6 +342,14 @@
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGMatrix.skewY Mozilla SVGMatrix.skewY documentation> 
 skewY_ :: (MonadIO m) => SVGMatrix -> Float -> m ()
 skewY_ self angle = liftIO (void (js_skewY (self) angle))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGMatrix.skewY Mozilla SVGMatrix.skewY documentation> 
+skewYUnsafe ::
+            (MonadIO m, HasCallStack) => SVGMatrix -> Float -> m SVGMatrix
+skewYUnsafe self angle
+  = liftIO
+      ((nullableToMaybe <$> (js_skewY (self) angle)) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGMatrix.skewY Mozilla SVGMatrix.skewY documentation> 
 skewYUnchecked :: (MonadIO m) => SVGMatrix -> Float -> m SVGMatrix
diff --git a/src/GHCJS/DOM/JSFFI/Generated/SVGNumber.hs b/src/GHCJS/DOM/JSFFI/Generated/SVGNumber.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/SVGNumber.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/SVGNumber.hs
@@ -1,9 +1,15 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.SVGNumber
-       (js_setValue, setValue, js_getValue, getValue, SVGNumber,
-        castToSVGNumber, gTypeSVGNumber)
+       (js_setValue, setValue, js_getValue, getValue, SVGNumber(..),
+        gTypeSVGNumber)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -19,6 +25,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"value\"] = $2;" js_setValue
         :: SVGNumber -> Float -> IO ()
diff --git a/src/GHCJS/DOM/JSFFI/Generated/SVGNumberList.hs b/src/GHCJS/DOM/JSFFI/Generated/SVGNumberList.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/SVGNumberList.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/SVGNumberList.hs
@@ -1,16 +1,23 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.SVGNumberList
        (js_clear, clear, js_initialize, initialize, initialize_,
-        initializeUnchecked, js_getItem, getItem, getItem_,
-        getItemUnchecked, js_insertItemBefore, insertItemBefore,
-        insertItemBefore_, insertItemBeforeUnchecked, js_replaceItem,
-        replaceItem, replaceItem_, replaceItemUnchecked, js_removeItem,
-        removeItem, removeItem_, removeItemUnchecked, js_appendItem,
-        appendItem, appendItem_, appendItemUnchecked, js_getNumberOfItems,
-        getNumberOfItems, SVGNumberList, castToSVGNumberList,
-        gTypeSVGNumberList)
+        initializeUnsafe, initializeUnchecked, js_getItem, getItem,
+        getItem_, getItemUnsafe, getItemUnchecked, js_insertItemBefore,
+        insertItemBefore, insertItemBefore_, insertItemBeforeUnsafe,
+        insertItemBeforeUnchecked, js_replaceItem, replaceItem,
+        replaceItem_, replaceItemUnsafe, replaceItemUnchecked,
+        js_removeItem, removeItem, removeItem_, removeItemUnsafe,
+        removeItemUnchecked, js_appendItem, appendItem, appendItem_,
+        appendItemUnsafe, appendItemUnchecked, js_getNumberOfItems,
+        getNumberOfItems, SVGNumberList(..), gTypeSVGNumberList)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -26,6 +33,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"clear\"]()" js_clear ::
         SVGNumberList -> IO ()
@@ -53,6 +70,16 @@
   = liftIO (void (js_initialize (self) (maybeToNullable item)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGNumberList.initialize Mozilla SVGNumberList.initialize documentation> 
+initializeUnsafe ::
+                 (MonadIO m, HasCallStack) =>
+                   SVGNumberList -> Maybe SVGNumber -> m SVGNumber
+initializeUnsafe self item
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_initialize (self) (maybeToNullable item)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGNumberList.initialize Mozilla SVGNumberList.initialize documentation> 
 initializeUnchecked ::
                     (MonadIO m) => SVGNumberList -> Maybe SVGNumber -> m SVGNumber
 initializeUnchecked self item
@@ -74,6 +101,14 @@
 getItem_ self index = liftIO (void (js_getItem (self) index))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGNumberList.getItem Mozilla SVGNumberList.getItem documentation> 
+getItemUnsafe ::
+              (MonadIO m, HasCallStack) => SVGNumberList -> Word -> m SVGNumber
+getItemUnsafe self index
+  = liftIO
+      ((nullableToMaybe <$> (js_getItem (self) index)) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGNumberList.getItem Mozilla SVGNumberList.getItem documentation> 
 getItemUnchecked ::
                  (MonadIO m) => SVGNumberList -> Word -> m SVGNumber
 getItemUnchecked self index
@@ -101,6 +136,16 @@
       (void (js_insertItemBefore (self) (maybeToNullable item) index))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGNumberList.insertItemBefore Mozilla SVGNumberList.insertItemBefore documentation> 
+insertItemBeforeUnsafe ::
+                       (MonadIO m, HasCallStack) =>
+                         SVGNumberList -> Maybe SVGNumber -> Word -> m SVGNumber
+insertItemBeforeUnsafe self item index
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_insertItemBefore (self) (maybeToNullable item) index))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGNumberList.insertItemBefore Mozilla SVGNumberList.insertItemBefore documentation> 
 insertItemBeforeUnchecked ::
                           (MonadIO m) =>
                             SVGNumberList -> Maybe SVGNumber -> Word -> m SVGNumber
@@ -131,6 +176,16 @@
       (void (js_replaceItem (self) (maybeToNullable item) index))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGNumberList.replaceItem Mozilla SVGNumberList.replaceItem documentation> 
+replaceItemUnsafe ::
+                  (MonadIO m, HasCallStack) =>
+                    SVGNumberList -> Maybe SVGNumber -> Word -> m SVGNumber
+replaceItemUnsafe self item index
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_replaceItem (self) (maybeToNullable item) index))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGNumberList.replaceItem Mozilla SVGNumberList.replaceItem documentation> 
 replaceItemUnchecked ::
                      (MonadIO m) =>
                        SVGNumberList -> Maybe SVGNumber -> Word -> m SVGNumber
@@ -153,6 +208,14 @@
 removeItem_ self index = liftIO (void (js_removeItem (self) index))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGNumberList.removeItem Mozilla SVGNumberList.removeItem documentation> 
+removeItemUnsafe ::
+                 (MonadIO m, HasCallStack) => SVGNumberList -> Word -> m SVGNumber
+removeItemUnsafe self index
+  = liftIO
+      ((nullableToMaybe <$> (js_removeItem (self) index)) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGNumberList.removeItem Mozilla SVGNumberList.removeItem documentation> 
 removeItemUnchecked ::
                     (MonadIO m) => SVGNumberList -> Word -> m SVGNumber
 removeItemUnchecked self index
@@ -176,6 +239,16 @@
             (MonadIO m) => SVGNumberList -> Maybe SVGNumber -> m ()
 appendItem_ self item
   = liftIO (void (js_appendItem (self) (maybeToNullable item)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGNumberList.appendItem Mozilla SVGNumberList.appendItem documentation> 
+appendItemUnsafe ::
+                 (MonadIO m, HasCallStack) =>
+                   SVGNumberList -> Maybe SVGNumber -> m SVGNumber
+appendItemUnsafe self item
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_appendItem (self) (maybeToNullable item)))
+         >>= maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGNumberList.appendItem Mozilla SVGNumberList.appendItem documentation> 
 appendItemUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/SVGPaint.hs b/src/GHCJS/DOM/JSFFI/Generated/SVGPaint.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/SVGPaint.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/SVGPaint.hs
@@ -1,4 +1,9 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.SVGPaint
        (js_setUri, setUri, js_setPaint, setPaint,
         pattern SVG_PAINTTYPE_UNKNOWN, pattern SVG_PAINTTYPE_RGBCOLOR,
@@ -9,9 +14,10 @@
         pattern SVG_PAINTTYPE_URI_RGBCOLOR,
         pattern SVG_PAINTTYPE_URI_RGBCOLOR_ICCCOLOR,
         pattern SVG_PAINTTYPE_URI, js_getPaintType, getPaintType,
-        js_getUri, getUri, SVGPaint, castToSVGPaint, gTypeSVGPaint)
+        js_getUri, getUri, SVGPaint(..), gTypeSVGPaint)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -27,6 +33,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"setUri\"]($2)" js_setUri ::
         SVGPaint -> JSString -> IO ()
diff --git a/src/GHCJS/DOM/JSFFI/Generated/SVGPathElement.hs b/src/GHCJS/DOM/JSFFI/Generated/SVGPathElement.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/SVGPathElement.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/SVGPathElement.hs
@@ -1,80 +1,107 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.SVGPathElement
        (js_getTotalLength, getTotalLength, getTotalLength_,
         js_getPointAtLength, getPointAtLength, getPointAtLength_,
-        getPointAtLengthUnchecked, js_getPathSegAtLength,
-        getPathSegAtLength, getPathSegAtLength_,
+        getPointAtLengthUnsafe, getPointAtLengthUnchecked,
+        js_getPathSegAtLength, getPathSegAtLength, getPathSegAtLength_,
         js_createSVGPathSegClosePath, createSVGPathSegClosePath,
-        createSVGPathSegClosePath_, createSVGPathSegClosePathUnchecked,
-        js_createSVGPathSegMovetoAbs, createSVGPathSegMovetoAbs,
-        createSVGPathSegMovetoAbs_, createSVGPathSegMovetoAbsUnchecked,
-        js_createSVGPathSegMovetoRel, createSVGPathSegMovetoRel,
-        createSVGPathSegMovetoRel_, createSVGPathSegMovetoRelUnchecked,
-        js_createSVGPathSegLinetoAbs, createSVGPathSegLinetoAbs,
-        createSVGPathSegLinetoAbs_, createSVGPathSegLinetoAbsUnchecked,
-        js_createSVGPathSegLinetoRel, createSVGPathSegLinetoRel,
-        createSVGPathSegLinetoRel_, createSVGPathSegLinetoRelUnchecked,
+        createSVGPathSegClosePath_, createSVGPathSegClosePathUnsafe,
+        createSVGPathSegClosePathUnchecked, js_createSVGPathSegMovetoAbs,
+        createSVGPathSegMovetoAbs, createSVGPathSegMovetoAbs_,
+        createSVGPathSegMovetoAbsUnsafe,
+        createSVGPathSegMovetoAbsUnchecked, js_createSVGPathSegMovetoRel,
+        createSVGPathSegMovetoRel, createSVGPathSegMovetoRel_,
+        createSVGPathSegMovetoRelUnsafe,
+        createSVGPathSegMovetoRelUnchecked, js_createSVGPathSegLinetoAbs,
+        createSVGPathSegLinetoAbs, createSVGPathSegLinetoAbs_,
+        createSVGPathSegLinetoAbsUnsafe,
+        createSVGPathSegLinetoAbsUnchecked, js_createSVGPathSegLinetoRel,
+        createSVGPathSegLinetoRel, createSVGPathSegLinetoRel_,
+        createSVGPathSegLinetoRelUnsafe,
+        createSVGPathSegLinetoRelUnchecked,
         js_createSVGPathSegCurvetoCubicAbs,
         createSVGPathSegCurvetoCubicAbs, createSVGPathSegCurvetoCubicAbs_,
+        createSVGPathSegCurvetoCubicAbsUnsafe,
         createSVGPathSegCurvetoCubicAbsUnchecked,
         js_createSVGPathSegCurvetoCubicRel,
         createSVGPathSegCurvetoCubicRel, createSVGPathSegCurvetoCubicRel_,
+        createSVGPathSegCurvetoCubicRelUnsafe,
         createSVGPathSegCurvetoCubicRelUnchecked,
         js_createSVGPathSegCurvetoQuadraticAbs,
         createSVGPathSegCurvetoQuadraticAbs,
         createSVGPathSegCurvetoQuadraticAbs_,
+        createSVGPathSegCurvetoQuadraticAbsUnsafe,
         createSVGPathSegCurvetoQuadraticAbsUnchecked,
         js_createSVGPathSegCurvetoQuadraticRel,
         createSVGPathSegCurvetoQuadraticRel,
         createSVGPathSegCurvetoQuadraticRel_,
+        createSVGPathSegCurvetoQuadraticRelUnsafe,
         createSVGPathSegCurvetoQuadraticRelUnchecked,
         js_createSVGPathSegArcAbs, createSVGPathSegArcAbs,
-        createSVGPathSegArcAbs_, createSVGPathSegArcAbsUnchecked,
-        js_createSVGPathSegArcRel, createSVGPathSegArcRel,
-        createSVGPathSegArcRel_, createSVGPathSegArcRelUnchecked,
+        createSVGPathSegArcAbs_, createSVGPathSegArcAbsUnsafe,
+        createSVGPathSegArcAbsUnchecked, js_createSVGPathSegArcRel,
+        createSVGPathSegArcRel, createSVGPathSegArcRel_,
+        createSVGPathSegArcRelUnsafe, createSVGPathSegArcRelUnchecked,
         js_createSVGPathSegLinetoHorizontalAbs,
         createSVGPathSegLinetoHorizontalAbs,
         createSVGPathSegLinetoHorizontalAbs_,
+        createSVGPathSegLinetoHorizontalAbsUnsafe,
         createSVGPathSegLinetoHorizontalAbsUnchecked,
         js_createSVGPathSegLinetoHorizontalRel,
         createSVGPathSegLinetoHorizontalRel,
         createSVGPathSegLinetoHorizontalRel_,
+        createSVGPathSegLinetoHorizontalRelUnsafe,
         createSVGPathSegLinetoHorizontalRelUnchecked,
         js_createSVGPathSegLinetoVerticalAbs,
         createSVGPathSegLinetoVerticalAbs,
         createSVGPathSegLinetoVerticalAbs_,
+        createSVGPathSegLinetoVerticalAbsUnsafe,
         createSVGPathSegLinetoVerticalAbsUnchecked,
         js_createSVGPathSegLinetoVerticalRel,
         createSVGPathSegLinetoVerticalRel,
         createSVGPathSegLinetoVerticalRel_,
+        createSVGPathSegLinetoVerticalRelUnsafe,
         createSVGPathSegLinetoVerticalRelUnchecked,
         js_createSVGPathSegCurvetoCubicSmoothAbs,
         createSVGPathSegCurvetoCubicSmoothAbs,
         createSVGPathSegCurvetoCubicSmoothAbs_,
+        createSVGPathSegCurvetoCubicSmoothAbsUnsafe,
         createSVGPathSegCurvetoCubicSmoothAbsUnchecked,
         js_createSVGPathSegCurvetoCubicSmoothRel,
         createSVGPathSegCurvetoCubicSmoothRel,
         createSVGPathSegCurvetoCubicSmoothRel_,
+        createSVGPathSegCurvetoCubicSmoothRelUnsafe,
         createSVGPathSegCurvetoCubicSmoothRelUnchecked,
         js_createSVGPathSegCurvetoQuadraticSmoothAbs,
         createSVGPathSegCurvetoQuadraticSmoothAbs,
         createSVGPathSegCurvetoQuadraticSmoothAbs_,
+        createSVGPathSegCurvetoQuadraticSmoothAbsUnsafe,
         createSVGPathSegCurvetoQuadraticSmoothAbsUnchecked,
         js_createSVGPathSegCurvetoQuadraticSmoothRel,
         createSVGPathSegCurvetoQuadraticSmoothRel,
         createSVGPathSegCurvetoQuadraticSmoothRel_,
+        createSVGPathSegCurvetoQuadraticSmoothRelUnsafe,
         createSVGPathSegCurvetoQuadraticSmoothRelUnchecked,
-        js_getPathLength, getPathLength, getPathLengthUnchecked,
-        js_getPathSegList, getPathSegList, getPathSegListUnchecked,
+        js_getPathLength, getPathLength, getPathLengthUnsafe,
+        getPathLengthUnchecked, js_getPathSegList, getPathSegList,
+        getPathSegListUnsafe, getPathSegListUnchecked,
         js_getNormalizedPathSegList, getNormalizedPathSegList,
-        getNormalizedPathSegListUnchecked, js_getAnimatedPathSegList,
-        getAnimatedPathSegList, getAnimatedPathSegListUnchecked,
+        getNormalizedPathSegListUnsafe, getNormalizedPathSegListUnchecked,
+        js_getAnimatedPathSegList, getAnimatedPathSegList,
+        getAnimatedPathSegListUnsafe, getAnimatedPathSegListUnchecked,
         js_getAnimatedNormalizedPathSegList,
         getAnimatedNormalizedPathSegList,
-        getAnimatedNormalizedPathSegListUnchecked, SVGPathElement,
-        castToSVGPathElement, gTypeSVGPathElement)
+        getAnimatedNormalizedPathSegListUnsafe,
+        getAnimatedNormalizedPathSegListUnchecked, SVGPathElement(..),
+        gTypeSVGPathElement)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -90,6 +117,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"getTotalLength\"]()"
         js_getTotalLength :: SVGPathElement -> IO Float
@@ -119,6 +156,14 @@
   = liftIO (void (js_getPointAtLength (self) distance))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathElement.getPointAtLength Mozilla SVGPathElement.getPointAtLength documentation> 
+getPointAtLengthUnsafe ::
+                       (MonadIO m, HasCallStack) => SVGPathElement -> Float -> m SVGPoint
+getPointAtLengthUnsafe self distance
+  = liftIO
+      ((nullableToMaybe <$> (js_getPointAtLength (self) distance)) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathElement.getPointAtLength Mozilla SVGPathElement.getPointAtLength documentation> 
 getPointAtLengthUnchecked ::
                           (MonadIO m) => SVGPathElement -> Float -> m SVGPoint
 getPointAtLengthUnchecked self distance
@@ -158,6 +203,15 @@
   = liftIO (void (js_createSVGPathSegClosePath (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathElement.createSVGPathSegClosePath Mozilla SVGPathElement.createSVGPathSegClosePath documentation> 
+createSVGPathSegClosePathUnsafe ::
+                                (MonadIO m, HasCallStack) =>
+                                  SVGPathElement -> m SVGPathSegClosePath
+createSVGPathSegClosePathUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_createSVGPathSegClosePath (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathElement.createSVGPathSegClosePath Mozilla SVGPathElement.createSVGPathSegClosePath documentation> 
 createSVGPathSegClosePathUnchecked ::
                                    (MonadIO m) => SVGPathElement -> m SVGPathSegClosePath
 createSVGPathSegClosePathUnchecked self
@@ -186,6 +240,15 @@
   = liftIO (void (js_createSVGPathSegMovetoAbs (self) x y))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathElement.createSVGPathSegMovetoAbs Mozilla SVGPathElement.createSVGPathSegMovetoAbs documentation> 
+createSVGPathSegMovetoAbsUnsafe ::
+                                (MonadIO m, HasCallStack) =>
+                                  SVGPathElement -> Float -> Float -> m SVGPathSegMovetoAbs
+createSVGPathSegMovetoAbsUnsafe self x y
+  = liftIO
+      ((nullableToMaybe <$> (js_createSVGPathSegMovetoAbs (self) x y))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathElement.createSVGPathSegMovetoAbs Mozilla SVGPathElement.createSVGPathSegMovetoAbs documentation> 
 createSVGPathSegMovetoAbsUnchecked ::
                                    (MonadIO m) =>
                                      SVGPathElement -> Float -> Float -> m SVGPathSegMovetoAbs
@@ -215,6 +278,15 @@
   = liftIO (void (js_createSVGPathSegMovetoRel (self) x y))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathElement.createSVGPathSegMovetoRel Mozilla SVGPathElement.createSVGPathSegMovetoRel documentation> 
+createSVGPathSegMovetoRelUnsafe ::
+                                (MonadIO m, HasCallStack) =>
+                                  SVGPathElement -> Float -> Float -> m SVGPathSegMovetoRel
+createSVGPathSegMovetoRelUnsafe self x y
+  = liftIO
+      ((nullableToMaybe <$> (js_createSVGPathSegMovetoRel (self) x y))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathElement.createSVGPathSegMovetoRel Mozilla SVGPathElement.createSVGPathSegMovetoRel documentation> 
 createSVGPathSegMovetoRelUnchecked ::
                                    (MonadIO m) =>
                                      SVGPathElement -> Float -> Float -> m SVGPathSegMovetoRel
@@ -244,6 +316,15 @@
   = liftIO (void (js_createSVGPathSegLinetoAbs (self) x y))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathElement.createSVGPathSegLinetoAbs Mozilla SVGPathElement.createSVGPathSegLinetoAbs documentation> 
+createSVGPathSegLinetoAbsUnsafe ::
+                                (MonadIO m, HasCallStack) =>
+                                  SVGPathElement -> Float -> Float -> m SVGPathSegLinetoAbs
+createSVGPathSegLinetoAbsUnsafe self x y
+  = liftIO
+      ((nullableToMaybe <$> (js_createSVGPathSegLinetoAbs (self) x y))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathElement.createSVGPathSegLinetoAbs Mozilla SVGPathElement.createSVGPathSegLinetoAbs documentation> 
 createSVGPathSegLinetoAbsUnchecked ::
                                    (MonadIO m) =>
                                      SVGPathElement -> Float -> Float -> m SVGPathSegLinetoAbs
@@ -273,6 +354,15 @@
   = liftIO (void (js_createSVGPathSegLinetoRel (self) x y))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathElement.createSVGPathSegLinetoRel Mozilla SVGPathElement.createSVGPathSegLinetoRel documentation> 
+createSVGPathSegLinetoRelUnsafe ::
+                                (MonadIO m, HasCallStack) =>
+                                  SVGPathElement -> Float -> Float -> m SVGPathSegLinetoRel
+createSVGPathSegLinetoRelUnsafe self x y
+  = liftIO
+      ((nullableToMaybe <$> (js_createSVGPathSegLinetoRel (self) x y))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathElement.createSVGPathSegLinetoRel Mozilla SVGPathElement.createSVGPathSegLinetoRel documentation> 
 createSVGPathSegLinetoRelUnchecked ::
                                    (MonadIO m) =>
                                      SVGPathElement -> Float -> Float -> m SVGPathSegLinetoRel
@@ -314,6 +404,21 @@
       (void (js_createSVGPathSegCurvetoCubicAbs (self) x y x1 y1 x2 y2))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathElement.createSVGPathSegCurvetoCubicAbs Mozilla SVGPathElement.createSVGPathSegCurvetoCubicAbs documentation> 
+createSVGPathSegCurvetoCubicAbsUnsafe ::
+                                      (MonadIO m, HasCallStack) =>
+                                        SVGPathElement ->
+                                          Float ->
+                                            Float ->
+                                              Float ->
+                                                Float ->
+                                                  Float -> Float -> m SVGPathSegCurvetoCubicAbs
+createSVGPathSegCurvetoCubicAbsUnsafe self x y x1 y1 x2 y2
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_createSVGPathSegCurvetoCubicAbs (self) x y x1 y1 x2 y2))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathElement.createSVGPathSegCurvetoCubicAbs Mozilla SVGPathElement.createSVGPathSegCurvetoCubicAbs documentation> 
 createSVGPathSegCurvetoCubicAbsUnchecked ::
                                          (MonadIO m) =>
                                            SVGPathElement ->
@@ -360,6 +465,21 @@
       (void (js_createSVGPathSegCurvetoCubicRel (self) x y x1 y1 x2 y2))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathElement.createSVGPathSegCurvetoCubicRel Mozilla SVGPathElement.createSVGPathSegCurvetoCubicRel documentation> 
+createSVGPathSegCurvetoCubicRelUnsafe ::
+                                      (MonadIO m, HasCallStack) =>
+                                        SVGPathElement ->
+                                          Float ->
+                                            Float ->
+                                              Float ->
+                                                Float ->
+                                                  Float -> Float -> m SVGPathSegCurvetoCubicRel
+createSVGPathSegCurvetoCubicRelUnsafe self x y x1 y1 x2 y2
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_createSVGPathSegCurvetoCubicRel (self) x y x1 y1 x2 y2))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathElement.createSVGPathSegCurvetoCubicRel Mozilla SVGPathElement.createSVGPathSegCurvetoCubicRel documentation> 
 createSVGPathSegCurvetoCubicRelUnchecked ::
                                          (MonadIO m) =>
                                            SVGPathElement ->
@@ -403,6 +523,19 @@
       (void (js_createSVGPathSegCurvetoQuadraticAbs (self) x y x1 y1))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathElement.createSVGPathSegCurvetoQuadraticAbs Mozilla SVGPathElement.createSVGPathSegCurvetoQuadraticAbs documentation> 
+createSVGPathSegCurvetoQuadraticAbsUnsafe ::
+                                          (MonadIO m, HasCallStack) =>
+                                            SVGPathElement ->
+                                              Float ->
+                                                Float ->
+                                                  Float -> Float -> m SVGPathSegCurvetoQuadraticAbs
+createSVGPathSegCurvetoQuadraticAbsUnsafe self x y x1 y1
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_createSVGPathSegCurvetoQuadraticAbs (self) x y x1 y1))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathElement.createSVGPathSegCurvetoQuadraticAbs Mozilla SVGPathElement.createSVGPathSegCurvetoQuadraticAbs documentation> 
 createSVGPathSegCurvetoQuadraticAbsUnchecked ::
                                              (MonadIO m) =>
                                                SVGPathElement ->
@@ -445,6 +578,19 @@
       (void (js_createSVGPathSegCurvetoQuadraticRel (self) x y x1 y1))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathElement.createSVGPathSegCurvetoQuadraticRel Mozilla SVGPathElement.createSVGPathSegCurvetoQuadraticRel documentation> 
+createSVGPathSegCurvetoQuadraticRelUnsafe ::
+                                          (MonadIO m, HasCallStack) =>
+                                            SVGPathElement ->
+                                              Float ->
+                                                Float ->
+                                                  Float -> Float -> m SVGPathSegCurvetoQuadraticRel
+createSVGPathSegCurvetoQuadraticRelUnsafe self x y x1 y1
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_createSVGPathSegCurvetoQuadraticRel (self) x y x1 y1))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathElement.createSVGPathSegCurvetoQuadraticRel Mozilla SVGPathElement.createSVGPathSegCurvetoQuadraticRel documentation> 
 createSVGPathSegCurvetoQuadraticRelUnchecked ::
                                              (MonadIO m) =>
                                                SVGPathElement ->
@@ -492,6 +638,21 @@
             sweepFlag))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathElement.createSVGPathSegArcAbs Mozilla SVGPathElement.createSVGPathSegArcAbs documentation> 
+createSVGPathSegArcAbsUnsafe ::
+                             (MonadIO m, HasCallStack) =>
+                               SVGPathElement ->
+                                 Float ->
+                                   Float ->
+                                     Float -> Float -> Float -> Bool -> Bool -> m SVGPathSegArcAbs
+createSVGPathSegArcAbsUnsafe self x y r1 r2 angle largeArcFlag
+  sweepFlag
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_createSVGPathSegArcAbs (self) x y r1 r2 angle largeArcFlag
+             sweepFlag))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathElement.createSVGPathSegArcAbs Mozilla SVGPathElement.createSVGPathSegArcAbs documentation> 
 createSVGPathSegArcAbsUnchecked ::
                                 (MonadIO m) =>
                                   SVGPathElement ->
@@ -541,6 +702,21 @@
             sweepFlag))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathElement.createSVGPathSegArcRel Mozilla SVGPathElement.createSVGPathSegArcRel documentation> 
+createSVGPathSegArcRelUnsafe ::
+                             (MonadIO m, HasCallStack) =>
+                               SVGPathElement ->
+                                 Float ->
+                                   Float ->
+                                     Float -> Float -> Float -> Bool -> Bool -> m SVGPathSegArcRel
+createSVGPathSegArcRelUnsafe self x y r1 r2 angle largeArcFlag
+  sweepFlag
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_createSVGPathSegArcRel (self) x y r1 r2 angle largeArcFlag
+             sweepFlag))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathElement.createSVGPathSegArcRel Mozilla SVGPathElement.createSVGPathSegArcRel documentation> 
 createSVGPathSegArcRelUnchecked ::
                                 (MonadIO m) =>
                                   SVGPathElement ->
@@ -578,6 +754,17 @@
   = liftIO (void (js_createSVGPathSegLinetoHorizontalAbs (self) x))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathElement.createSVGPathSegLinetoHorizontalAbs Mozilla SVGPathElement.createSVGPathSegLinetoHorizontalAbs documentation> 
+createSVGPathSegLinetoHorizontalAbsUnsafe ::
+                                          (MonadIO m, HasCallStack) =>
+                                            SVGPathElement ->
+                                              Float -> m SVGPathSegLinetoHorizontalAbs
+createSVGPathSegLinetoHorizontalAbsUnsafe self x
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_createSVGPathSegLinetoHorizontalAbs (self) x))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathElement.createSVGPathSegLinetoHorizontalAbs Mozilla SVGPathElement.createSVGPathSegLinetoHorizontalAbs documentation> 
 createSVGPathSegLinetoHorizontalAbsUnchecked ::
                                              (MonadIO m) =>
                                                SVGPathElement ->
@@ -610,6 +797,17 @@
   = liftIO (void (js_createSVGPathSegLinetoHorizontalRel (self) x))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathElement.createSVGPathSegLinetoHorizontalRel Mozilla SVGPathElement.createSVGPathSegLinetoHorizontalRel documentation> 
+createSVGPathSegLinetoHorizontalRelUnsafe ::
+                                          (MonadIO m, HasCallStack) =>
+                                            SVGPathElement ->
+                                              Float -> m SVGPathSegLinetoHorizontalRel
+createSVGPathSegLinetoHorizontalRelUnsafe self x
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_createSVGPathSegLinetoHorizontalRel (self) x))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathElement.createSVGPathSegLinetoHorizontalRel Mozilla SVGPathElement.createSVGPathSegLinetoHorizontalRel documentation> 
 createSVGPathSegLinetoHorizontalRelUnchecked ::
                                              (MonadIO m) =>
                                                SVGPathElement ->
@@ -641,6 +839,16 @@
   = liftIO (void (js_createSVGPathSegLinetoVerticalAbs (self) y))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathElement.createSVGPathSegLinetoVerticalAbs Mozilla SVGPathElement.createSVGPathSegLinetoVerticalAbs documentation> 
+createSVGPathSegLinetoVerticalAbsUnsafe ::
+                                        (MonadIO m, HasCallStack) =>
+                                          SVGPathElement -> Float -> m SVGPathSegLinetoVerticalAbs
+createSVGPathSegLinetoVerticalAbsUnsafe self y
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_createSVGPathSegLinetoVerticalAbs (self) y))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathElement.createSVGPathSegLinetoVerticalAbs Mozilla SVGPathElement.createSVGPathSegLinetoVerticalAbs documentation> 
 createSVGPathSegLinetoVerticalAbsUnchecked ::
                                            (MonadIO m) =>
                                              SVGPathElement ->
@@ -672,6 +880,16 @@
   = liftIO (void (js_createSVGPathSegLinetoVerticalRel (self) y))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathElement.createSVGPathSegLinetoVerticalRel Mozilla SVGPathElement.createSVGPathSegLinetoVerticalRel documentation> 
+createSVGPathSegLinetoVerticalRelUnsafe ::
+                                        (MonadIO m, HasCallStack) =>
+                                          SVGPathElement -> Float -> m SVGPathSegLinetoVerticalRel
+createSVGPathSegLinetoVerticalRelUnsafe self y
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_createSVGPathSegLinetoVerticalRel (self) y))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathElement.createSVGPathSegLinetoVerticalRel Mozilla SVGPathElement.createSVGPathSegLinetoVerticalRel documentation> 
 createSVGPathSegLinetoVerticalRelUnchecked ::
                                            (MonadIO m) =>
                                              SVGPathElement ->
@@ -711,6 +929,20 @@
       (void (js_createSVGPathSegCurvetoCubicSmoothAbs (self) x y x2 y2))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathElement.createSVGPathSegCurvetoCubicSmoothAbs Mozilla SVGPathElement.createSVGPathSegCurvetoCubicSmoothAbs documentation> 
+createSVGPathSegCurvetoCubicSmoothAbsUnsafe ::
+                                            (MonadIO m, HasCallStack) =>
+                                              SVGPathElement ->
+                                                Float ->
+                                                  Float ->
+                                                    Float ->
+                                                      Float -> m SVGPathSegCurvetoCubicSmoothAbs
+createSVGPathSegCurvetoCubicSmoothAbsUnsafe self x y x2 y2
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_createSVGPathSegCurvetoCubicSmoothAbs (self) x y x2 y2))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathElement.createSVGPathSegCurvetoCubicSmoothAbs Mozilla SVGPathElement.createSVGPathSegCurvetoCubicSmoothAbs documentation> 
 createSVGPathSegCurvetoCubicSmoothAbsUnchecked ::
                                                (MonadIO m) =>
                                                  SVGPathElement ->
@@ -753,6 +985,20 @@
       (void (js_createSVGPathSegCurvetoCubicSmoothRel (self) x y x2 y2))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathElement.createSVGPathSegCurvetoCubicSmoothRel Mozilla SVGPathElement.createSVGPathSegCurvetoCubicSmoothRel documentation> 
+createSVGPathSegCurvetoCubicSmoothRelUnsafe ::
+                                            (MonadIO m, HasCallStack) =>
+                                              SVGPathElement ->
+                                                Float ->
+                                                  Float ->
+                                                    Float ->
+                                                      Float -> m SVGPathSegCurvetoCubicSmoothRel
+createSVGPathSegCurvetoCubicSmoothRelUnsafe self x y x2 y2
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_createSVGPathSegCurvetoCubicSmoothRel (self) x y x2 y2))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathElement.createSVGPathSegCurvetoCubicSmoothRel Mozilla SVGPathElement.createSVGPathSegCurvetoCubicSmoothRel documentation> 
 createSVGPathSegCurvetoCubicSmoothRelUnchecked ::
                                                (MonadIO m) =>
                                                  SVGPathElement ->
@@ -791,6 +1037,18 @@
       (void (js_createSVGPathSegCurvetoQuadraticSmoothAbs (self) x y))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathElement.createSVGPathSegCurvetoQuadraticSmoothAbs Mozilla SVGPathElement.createSVGPathSegCurvetoQuadraticSmoothAbs documentation> 
+createSVGPathSegCurvetoQuadraticSmoothAbsUnsafe ::
+                                                (MonadIO m, HasCallStack) =>
+                                                  SVGPathElement ->
+                                                    Float ->
+                                                      Float -> m SVGPathSegCurvetoQuadraticSmoothAbs
+createSVGPathSegCurvetoQuadraticSmoothAbsUnsafe self x y
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_createSVGPathSegCurvetoQuadraticSmoothAbs (self) x y))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathElement.createSVGPathSegCurvetoQuadraticSmoothAbs Mozilla SVGPathElement.createSVGPathSegCurvetoQuadraticSmoothAbs documentation> 
 createSVGPathSegCurvetoQuadraticSmoothAbsUnchecked ::
                                                    (MonadIO m) =>
                                                      SVGPathElement ->
@@ -828,6 +1086,18 @@
       (void (js_createSVGPathSegCurvetoQuadraticSmoothRel (self) x y))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathElement.createSVGPathSegCurvetoQuadraticSmoothRel Mozilla SVGPathElement.createSVGPathSegCurvetoQuadraticSmoothRel documentation> 
+createSVGPathSegCurvetoQuadraticSmoothRelUnsafe ::
+                                                (MonadIO m, HasCallStack) =>
+                                                  SVGPathElement ->
+                                                    Float ->
+                                                      Float -> m SVGPathSegCurvetoQuadraticSmoothRel
+createSVGPathSegCurvetoQuadraticSmoothRelUnsafe self x y
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_createSVGPathSegCurvetoQuadraticSmoothRel (self) x y))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathElement.createSVGPathSegCurvetoQuadraticSmoothRel Mozilla SVGPathElement.createSVGPathSegCurvetoQuadraticSmoothRel documentation> 
 createSVGPathSegCurvetoQuadraticSmoothRelUnchecked ::
                                                    (MonadIO m) =>
                                                      SVGPathElement ->
@@ -850,6 +1120,14 @@
   = liftIO (nullableToMaybe <$> (js_getPathLength (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathElement.pathLength Mozilla SVGPathElement.pathLength documentation> 
+getPathLengthUnsafe ::
+                    (MonadIO m, HasCallStack) => SVGPathElement -> m SVGAnimatedNumber
+getPathLengthUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getPathLength (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathElement.pathLength Mozilla SVGPathElement.pathLength documentation> 
 getPathLengthUnchecked ::
                        (MonadIO m) => SVGPathElement -> m SVGAnimatedNumber
 getPathLengthUnchecked self
@@ -865,6 +1143,14 @@
   = liftIO (nullableToMaybe <$> (js_getPathSegList (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathElement.pathSegList Mozilla SVGPathElement.pathSegList documentation> 
+getPathSegListUnsafe ::
+                     (MonadIO m, HasCallStack) => SVGPathElement -> m SVGPathSegList
+getPathSegListUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getPathSegList (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathElement.pathSegList Mozilla SVGPathElement.pathSegList documentation> 
 getPathSegListUnchecked ::
                         (MonadIO m) => SVGPathElement -> m SVGPathSegList
 getPathSegListUnchecked self
@@ -882,6 +1168,14 @@
   = liftIO (nullableToMaybe <$> (js_getNormalizedPathSegList (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathElement.normalizedPathSegList Mozilla SVGPathElement.normalizedPathSegList documentation> 
+getNormalizedPathSegListUnsafe ::
+                               (MonadIO m, HasCallStack) => SVGPathElement -> m SVGPathSegList
+getNormalizedPathSegListUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getNormalizedPathSegList (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathElement.normalizedPathSegList Mozilla SVGPathElement.normalizedPathSegList documentation> 
 getNormalizedPathSegListUnchecked ::
                                   (MonadIO m) => SVGPathElement -> m SVGPathSegList
 getNormalizedPathSegListUnchecked self
@@ -900,6 +1194,14 @@
   = liftIO (nullableToMaybe <$> (js_getAnimatedPathSegList (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathElement.animatedPathSegList Mozilla SVGPathElement.animatedPathSegList documentation> 
+getAnimatedPathSegListUnsafe ::
+                             (MonadIO m, HasCallStack) => SVGPathElement -> m SVGPathSegList
+getAnimatedPathSegListUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getAnimatedPathSegList (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathElement.animatedPathSegList Mozilla SVGPathElement.animatedPathSegList documentation> 
 getAnimatedPathSegListUnchecked ::
                                 (MonadIO m) => SVGPathElement -> m SVGPathSegList
 getAnimatedPathSegListUnchecked self
@@ -917,6 +1219,15 @@
 getAnimatedNormalizedPathSegList self
   = liftIO
       (nullableToMaybe <$> (js_getAnimatedNormalizedPathSegList (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathElement.animatedNormalizedPathSegList Mozilla SVGPathElement.animatedNormalizedPathSegList documentation> 
+getAnimatedNormalizedPathSegListUnsafe ::
+                                       (MonadIO m, HasCallStack) =>
+                                         SVGPathElement -> m SVGPathSegList
+getAnimatedNormalizedPathSegListUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getAnimatedNormalizedPathSegList (self)))
+         >>= maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathElement.animatedNormalizedPathSegList Mozilla SVGPathElement.animatedNormalizedPathSegList documentation> 
 getAnimatedNormalizedPathSegListUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/SVGPathSeg.hs b/src/GHCJS/DOM/JSFFI/Generated/SVGPathSeg.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/SVGPathSeg.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/SVGPathSeg.hs
@@ -1,4 +1,9 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.SVGPathSeg
        (pattern PATHSEG_UNKNOWN, pattern PATHSEG_CLOSEPATH,
         pattern PATHSEG_MOVETO_ABS, pattern PATHSEG_MOVETO_REL,
@@ -16,10 +21,10 @@
         pattern PATHSEG_CURVETO_QUADRATIC_SMOOTH_ABS,
         pattern PATHSEG_CURVETO_QUADRATIC_SMOOTH_REL, js_getPathSegType,
         getPathSegType, js_getPathSegTypeAsLetter, getPathSegTypeAsLetter,
-        SVGPathSeg, castToSVGPathSeg, gTypeSVGPathSeg, IsSVGPathSeg,
-        toSVGPathSeg)
+        SVGPathSeg(..), gTypeSVGPathSeg, IsSVGPathSeg, toSVGPathSeg)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -35,6 +40,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
 pattern PATHSEG_UNKNOWN = 0
 pattern PATHSEG_CLOSEPATH = 1
 pattern PATHSEG_MOVETO_ABS = 2
diff --git a/src/GHCJS/DOM/JSFFI/Generated/SVGPathSegArcAbs.hs b/src/GHCJS/DOM/JSFFI/Generated/SVGPathSegArcAbs.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/SVGPathSegArcAbs.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/SVGPathSegArcAbs.hs
@@ -1,13 +1,19 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.SVGPathSegArcAbs
        (js_setX, setX, js_getX, getX, js_setY, setY, js_getY, getY,
         js_setR1, setR1, js_getR1, getR1, js_setR2, setR2, js_getR2, getR2,
         js_setAngle, setAngle, js_getAngle, getAngle, js_setLargeArcFlag,
         setLargeArcFlag, js_getLargeArcFlag, getLargeArcFlag,
         js_setSweepFlag, setSweepFlag, js_getSweepFlag, getSweepFlag,
-        SVGPathSegArcAbs, castToSVGPathSegArcAbs, gTypeSVGPathSegArcAbs)
+        SVGPathSegArcAbs(..), gTypeSVGPathSegArcAbs)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -23,6 +29,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"x\"] = $2;" js_setX ::
         SVGPathSegArcAbs -> Float -> IO ()
diff --git a/src/GHCJS/DOM/JSFFI/Generated/SVGPathSegArcRel.hs b/src/GHCJS/DOM/JSFFI/Generated/SVGPathSegArcRel.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/SVGPathSegArcRel.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/SVGPathSegArcRel.hs
@@ -1,13 +1,19 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.SVGPathSegArcRel
        (js_setX, setX, js_getX, getX, js_setY, setY, js_getY, getY,
         js_setR1, setR1, js_getR1, getR1, js_setR2, setR2, js_getR2, getR2,
         js_setAngle, setAngle, js_getAngle, getAngle, js_setLargeArcFlag,
         setLargeArcFlag, js_getLargeArcFlag, getLargeArcFlag,
         js_setSweepFlag, setSweepFlag, js_getSweepFlag, getSweepFlag,
-        SVGPathSegArcRel, castToSVGPathSegArcRel, gTypeSVGPathSegArcRel)
+        SVGPathSegArcRel(..), gTypeSVGPathSegArcRel)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -23,6 +29,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"x\"] = $2;" js_setX ::
         SVGPathSegArcRel -> Float -> IO ()
diff --git a/src/GHCJS/DOM/JSFFI/Generated/SVGPathSegCurvetoCubicAbs.hs b/src/GHCJS/DOM/JSFFI/Generated/SVGPathSegCurvetoCubicAbs.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/SVGPathSegCurvetoCubicAbs.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/SVGPathSegCurvetoCubicAbs.hs
@@ -1,12 +1,17 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.SVGPathSegCurvetoCubicAbs
        (js_setX, setX, js_getX, getX, js_setY, setY, js_getY, getY,
         js_setX1, setX1, js_getX1, getX1, js_setY1, setY1, js_getY1, getY1,
         js_setX2, setX2, js_getX2, getX2, js_setY2, setY2, js_getY2, getY2,
-        SVGPathSegCurvetoCubicAbs, castToSVGPathSegCurvetoCubicAbs,
-        gTypeSVGPathSegCurvetoCubicAbs)
+        SVGPathSegCurvetoCubicAbs(..), gTypeSVGPathSegCurvetoCubicAbs)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -22,6 +27,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"x\"] = $2;" js_setX ::
         SVGPathSegCurvetoCubicAbs -> Float -> IO ()
diff --git a/src/GHCJS/DOM/JSFFI/Generated/SVGPathSegCurvetoCubicRel.hs b/src/GHCJS/DOM/JSFFI/Generated/SVGPathSegCurvetoCubicRel.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/SVGPathSegCurvetoCubicRel.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/SVGPathSegCurvetoCubicRel.hs
@@ -1,12 +1,17 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.SVGPathSegCurvetoCubicRel
        (js_setX, setX, js_getX, getX, js_setY, setY, js_getY, getY,
         js_setX1, setX1, js_getX1, getX1, js_setY1, setY1, js_getY1, getY1,
         js_setX2, setX2, js_getX2, getX2, js_setY2, setY2, js_getY2, getY2,
-        SVGPathSegCurvetoCubicRel, castToSVGPathSegCurvetoCubicRel,
-        gTypeSVGPathSegCurvetoCubicRel)
+        SVGPathSegCurvetoCubicRel(..), gTypeSVGPathSegCurvetoCubicRel)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -22,6 +27,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"x\"] = $2;" js_setX ::
         SVGPathSegCurvetoCubicRel -> Float -> IO ()
diff --git a/src/GHCJS/DOM/JSFFI/Generated/SVGPathSegCurvetoCubicSmoothAbs.hs b/src/GHCJS/DOM/JSFFI/Generated/SVGPathSegCurvetoCubicSmoothAbs.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/SVGPathSegCurvetoCubicSmoothAbs.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/SVGPathSegCurvetoCubicSmoothAbs.hs
@@ -1,12 +1,17 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.SVGPathSegCurvetoCubicSmoothAbs
        (js_setX, setX, js_getX, getX, js_setY, setY, js_getY, getY,
         js_setX2, setX2, js_getX2, getX2, js_setY2, setY2, js_getY2, getY2,
-        SVGPathSegCurvetoCubicSmoothAbs,
-        castToSVGPathSegCurvetoCubicSmoothAbs,
+        SVGPathSegCurvetoCubicSmoothAbs(..),
         gTypeSVGPathSegCurvetoCubicSmoothAbs)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -22,6 +27,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"x\"] = $2;" js_setX ::
         SVGPathSegCurvetoCubicSmoothAbs -> Float -> IO ()
diff --git a/src/GHCJS/DOM/JSFFI/Generated/SVGPathSegCurvetoCubicSmoothRel.hs b/src/GHCJS/DOM/JSFFI/Generated/SVGPathSegCurvetoCubicSmoothRel.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/SVGPathSegCurvetoCubicSmoothRel.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/SVGPathSegCurvetoCubicSmoothRel.hs
@@ -1,12 +1,17 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.SVGPathSegCurvetoCubicSmoothRel
        (js_setX, setX, js_getX, getX, js_setY, setY, js_getY, getY,
         js_setX2, setX2, js_getX2, getX2, js_setY2, setY2, js_getY2, getY2,
-        SVGPathSegCurvetoCubicSmoothRel,
-        castToSVGPathSegCurvetoCubicSmoothRel,
+        SVGPathSegCurvetoCubicSmoothRel(..),
         gTypeSVGPathSegCurvetoCubicSmoothRel)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -22,6 +27,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"x\"] = $2;" js_setX ::
         SVGPathSegCurvetoCubicSmoothRel -> Float -> IO ()
diff --git a/src/GHCJS/DOM/JSFFI/Generated/SVGPathSegCurvetoQuadraticAbs.hs b/src/GHCJS/DOM/JSFFI/Generated/SVGPathSegCurvetoQuadraticAbs.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/SVGPathSegCurvetoQuadraticAbs.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/SVGPathSegCurvetoQuadraticAbs.hs
@@ -1,11 +1,17 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.SVGPathSegCurvetoQuadraticAbs
        (js_setX, setX, js_getX, getX, js_setY, setY, js_getY, getY,
         js_setX1, setX1, js_getX1, getX1, js_setY1, setY1, js_getY1, getY1,
-        SVGPathSegCurvetoQuadraticAbs, castToSVGPathSegCurvetoQuadraticAbs,
+        SVGPathSegCurvetoQuadraticAbs(..),
         gTypeSVGPathSegCurvetoQuadraticAbs)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -21,6 +27,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"x\"] = $2;" js_setX ::
         SVGPathSegCurvetoQuadraticAbs -> Float -> IO ()
diff --git a/src/GHCJS/DOM/JSFFI/Generated/SVGPathSegCurvetoQuadraticRel.hs b/src/GHCJS/DOM/JSFFI/Generated/SVGPathSegCurvetoQuadraticRel.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/SVGPathSegCurvetoQuadraticRel.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/SVGPathSegCurvetoQuadraticRel.hs
@@ -1,11 +1,17 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.SVGPathSegCurvetoQuadraticRel
        (js_setX, setX, js_getX, getX, js_setY, setY, js_getY, getY,
         js_setX1, setX1, js_getX1, getX1, js_setY1, setY1, js_getY1, getY1,
-        SVGPathSegCurvetoQuadraticRel, castToSVGPathSegCurvetoQuadraticRel,
+        SVGPathSegCurvetoQuadraticRel(..),
         gTypeSVGPathSegCurvetoQuadraticRel)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -21,6 +27,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"x\"] = $2;" js_setX ::
         SVGPathSegCurvetoQuadraticRel -> Float -> IO ()
diff --git a/src/GHCJS/DOM/JSFFI/Generated/SVGPathSegCurvetoQuadraticSmoothAbs.hs b/src/GHCJS/DOM/JSFFI/Generated/SVGPathSegCurvetoQuadraticSmoothAbs.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/SVGPathSegCurvetoQuadraticSmoothAbs.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/SVGPathSegCurvetoQuadraticSmoothAbs.hs
@@ -1,11 +1,16 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.SVGPathSegCurvetoQuadraticSmoothAbs
        (js_setX, setX, js_getX, getX, js_setY, setY, js_getY, getY,
-        SVGPathSegCurvetoQuadraticSmoothAbs,
-        castToSVGPathSegCurvetoQuadraticSmoothAbs,
+        SVGPathSegCurvetoQuadraticSmoothAbs(..),
         gTypeSVGPathSegCurvetoQuadraticSmoothAbs)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -21,6 +26,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"x\"] = $2;" js_setX ::
         SVGPathSegCurvetoQuadraticSmoothAbs -> Float -> IO ()
diff --git a/src/GHCJS/DOM/JSFFI/Generated/SVGPathSegCurvetoQuadraticSmoothRel.hs b/src/GHCJS/DOM/JSFFI/Generated/SVGPathSegCurvetoQuadraticSmoothRel.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/SVGPathSegCurvetoQuadraticSmoothRel.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/SVGPathSegCurvetoQuadraticSmoothRel.hs
@@ -1,11 +1,16 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.SVGPathSegCurvetoQuadraticSmoothRel
        (js_setX, setX, js_getX, getX, js_setY, setY, js_getY, getY,
-        SVGPathSegCurvetoQuadraticSmoothRel,
-        castToSVGPathSegCurvetoQuadraticSmoothRel,
+        SVGPathSegCurvetoQuadraticSmoothRel(..),
         gTypeSVGPathSegCurvetoQuadraticSmoothRel)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -21,6 +26,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"x\"] = $2;" js_setX ::
         SVGPathSegCurvetoQuadraticSmoothRel -> Float -> IO ()
diff --git a/src/GHCJS/DOM/JSFFI/Generated/SVGPathSegLinetoAbs.hs b/src/GHCJS/DOM/JSFFI/Generated/SVGPathSegLinetoAbs.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/SVGPathSegLinetoAbs.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/SVGPathSegLinetoAbs.hs
@@ -1,10 +1,15 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.SVGPathSegLinetoAbs
        (js_setX, setX, js_getX, getX, js_setY, setY, js_getY, getY,
-        SVGPathSegLinetoAbs, castToSVGPathSegLinetoAbs,
-        gTypeSVGPathSegLinetoAbs)
+        SVGPathSegLinetoAbs(..), gTypeSVGPathSegLinetoAbs)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -20,6 +25,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"x\"] = $2;" js_setX ::
         SVGPathSegLinetoAbs -> Float -> IO ()
diff --git a/src/GHCJS/DOM/JSFFI/Generated/SVGPathSegLinetoHorizontalAbs.hs b/src/GHCJS/DOM/JSFFI/Generated/SVGPathSegLinetoHorizontalAbs.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/SVGPathSegLinetoHorizontalAbs.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/SVGPathSegLinetoHorizontalAbs.hs
@@ -1,10 +1,15 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.SVGPathSegLinetoHorizontalAbs
-       (js_setX, setX, js_getX, getX, SVGPathSegLinetoHorizontalAbs,
-        castToSVGPathSegLinetoHorizontalAbs,
+       (js_setX, setX, js_getX, getX, SVGPathSegLinetoHorizontalAbs(..),
         gTypeSVGPathSegLinetoHorizontalAbs)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -20,6 +25,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"x\"] = $2;" js_setX ::
         SVGPathSegLinetoHorizontalAbs -> Float -> IO ()
diff --git a/src/GHCJS/DOM/JSFFI/Generated/SVGPathSegLinetoHorizontalRel.hs b/src/GHCJS/DOM/JSFFI/Generated/SVGPathSegLinetoHorizontalRel.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/SVGPathSegLinetoHorizontalRel.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/SVGPathSegLinetoHorizontalRel.hs
@@ -1,10 +1,15 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.SVGPathSegLinetoHorizontalRel
-       (js_setX, setX, js_getX, getX, SVGPathSegLinetoHorizontalRel,
-        castToSVGPathSegLinetoHorizontalRel,
+       (js_setX, setX, js_getX, getX, SVGPathSegLinetoHorizontalRel(..),
         gTypeSVGPathSegLinetoHorizontalRel)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -20,6 +25,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"x\"] = $2;" js_setX ::
         SVGPathSegLinetoHorizontalRel -> Float -> IO ()
diff --git a/src/GHCJS/DOM/JSFFI/Generated/SVGPathSegLinetoRel.hs b/src/GHCJS/DOM/JSFFI/Generated/SVGPathSegLinetoRel.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/SVGPathSegLinetoRel.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/SVGPathSegLinetoRel.hs
@@ -1,10 +1,15 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.SVGPathSegLinetoRel
        (js_setX, setX, js_getX, getX, js_setY, setY, js_getY, getY,
-        SVGPathSegLinetoRel, castToSVGPathSegLinetoRel,
-        gTypeSVGPathSegLinetoRel)
+        SVGPathSegLinetoRel(..), gTypeSVGPathSegLinetoRel)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -20,6 +25,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"x\"] = $2;" js_setX ::
         SVGPathSegLinetoRel -> Float -> IO ()
diff --git a/src/GHCJS/DOM/JSFFI/Generated/SVGPathSegLinetoVerticalAbs.hs b/src/GHCJS/DOM/JSFFI/Generated/SVGPathSegLinetoVerticalAbs.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/SVGPathSegLinetoVerticalAbs.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/SVGPathSegLinetoVerticalAbs.hs
@@ -1,10 +1,15 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.SVGPathSegLinetoVerticalAbs
-       (js_setY, setY, js_getY, getY, SVGPathSegLinetoVerticalAbs,
-        castToSVGPathSegLinetoVerticalAbs,
+       (js_setY, setY, js_getY, getY, SVGPathSegLinetoVerticalAbs(..),
         gTypeSVGPathSegLinetoVerticalAbs)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -20,6 +25,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"y\"] = $2;" js_setY ::
         SVGPathSegLinetoVerticalAbs -> Float -> IO ()
diff --git a/src/GHCJS/DOM/JSFFI/Generated/SVGPathSegLinetoVerticalRel.hs b/src/GHCJS/DOM/JSFFI/Generated/SVGPathSegLinetoVerticalRel.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/SVGPathSegLinetoVerticalRel.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/SVGPathSegLinetoVerticalRel.hs
@@ -1,10 +1,15 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.SVGPathSegLinetoVerticalRel
-       (js_setY, setY, js_getY, getY, SVGPathSegLinetoVerticalRel,
-        castToSVGPathSegLinetoVerticalRel,
+       (js_setY, setY, js_getY, getY, SVGPathSegLinetoVerticalRel(..),
         gTypeSVGPathSegLinetoVerticalRel)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -20,6 +25,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"y\"] = $2;" js_setY ::
         SVGPathSegLinetoVerticalRel -> Float -> IO ()
diff --git a/src/GHCJS/DOM/JSFFI/Generated/SVGPathSegList.hs b/src/GHCJS/DOM/JSFFI/Generated/SVGPathSegList.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/SVGPathSegList.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/SVGPathSegList.hs
@@ -1,16 +1,23 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.SVGPathSegList
        (js_clear, clear, js_initialize, initialize, initialize_,
-        initializeUnchecked, js_getItem, getItem, getItem_,
-        getItemUnchecked, js_insertItemBefore, insertItemBefore,
-        insertItemBefore_, insertItemBeforeUnchecked, js_replaceItem,
-        replaceItem, replaceItem_, replaceItemUnchecked, js_removeItem,
-        removeItem, removeItem_, removeItemUnchecked, js_appendItem,
-        appendItem, appendItem_, appendItemUnchecked, js_getNumberOfItems,
-        getNumberOfItems, SVGPathSegList, castToSVGPathSegList,
-        gTypeSVGPathSegList)
+        initializeUnsafe, initializeUnchecked, js_getItem, getItem,
+        getItem_, getItemUnsafe, getItemUnchecked, js_insertItemBefore,
+        insertItemBefore, insertItemBefore_, insertItemBeforeUnsafe,
+        insertItemBeforeUnchecked, js_replaceItem, replaceItem,
+        replaceItem_, replaceItemUnsafe, replaceItemUnchecked,
+        js_removeItem, removeItem, removeItem_, removeItemUnsafe,
+        removeItemUnchecked, js_appendItem, appendItem, appendItem_,
+        appendItemUnsafe, appendItemUnchecked, js_getNumberOfItems,
+        getNumberOfItems, SVGPathSegList(..), gTypeSVGPathSegList)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -26,6 +33,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"clear\"]()" js_clear ::
         SVGPathSegList -> IO ()
@@ -59,6 +76,17 @@
             (maybeToNullable (fmap toSVGPathSeg newItem))))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathSegList.initialize Mozilla SVGPathSegList.initialize documentation> 
+initializeUnsafe ::
+                 (MonadIO m, IsSVGPathSeg newItem, HasCallStack) =>
+                   SVGPathSegList -> Maybe newItem -> m SVGPathSeg
+initializeUnsafe self newItem
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_initialize (self)
+             (maybeToNullable (fmap toSVGPathSeg newItem))))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathSegList.initialize Mozilla SVGPathSegList.initialize documentation> 
 initializeUnchecked ::
                     (MonadIO m, IsSVGPathSeg newItem) =>
                       SVGPathSegList -> Maybe newItem -> m SVGPathSeg
@@ -82,6 +110,14 @@
 getItem_ self index = liftIO (void (js_getItem (self) index))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathSegList.getItem Mozilla SVGPathSegList.getItem documentation> 
+getItemUnsafe ::
+              (MonadIO m, HasCallStack) => SVGPathSegList -> Word -> m SVGPathSeg
+getItemUnsafe self index
+  = liftIO
+      ((nullableToMaybe <$> (js_getItem (self) index)) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathSegList.getItem Mozilla SVGPathSegList.getItem documentation> 
 getItemUnchecked ::
                  (MonadIO m) => SVGPathSegList -> Word -> m SVGPathSeg
 getItemUnchecked self index
@@ -115,6 +151,18 @@
             index))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathSegList.insertItemBefore Mozilla SVGPathSegList.insertItemBefore documentation> 
+insertItemBeforeUnsafe ::
+                       (MonadIO m, IsSVGPathSeg newItem, HasCallStack) =>
+                         SVGPathSegList -> Maybe newItem -> Word -> m SVGPathSeg
+insertItemBeforeUnsafe self newItem index
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_insertItemBefore (self)
+             (maybeToNullable (fmap toSVGPathSeg newItem))
+             index))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathSegList.insertItemBefore Mozilla SVGPathSegList.insertItemBefore documentation> 
 insertItemBeforeUnchecked ::
                           (MonadIO m, IsSVGPathSeg newItem) =>
                             SVGPathSegList -> Maybe newItem -> Word -> m SVGPathSeg
@@ -153,6 +201,18 @@
             index))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathSegList.replaceItem Mozilla SVGPathSegList.replaceItem documentation> 
+replaceItemUnsafe ::
+                  (MonadIO m, IsSVGPathSeg newItem, HasCallStack) =>
+                    SVGPathSegList -> Maybe newItem -> Word -> m SVGPathSeg
+replaceItemUnsafe self newItem index
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_replaceItem (self)
+             (maybeToNullable (fmap toSVGPathSeg newItem))
+             index))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathSegList.replaceItem Mozilla SVGPathSegList.replaceItem documentation> 
 replaceItemUnchecked ::
                      (MonadIO m, IsSVGPathSeg newItem) =>
                        SVGPathSegList -> Maybe newItem -> Word -> m SVGPathSeg
@@ -177,6 +237,14 @@
 removeItem_ self index = liftIO (void (js_removeItem (self) index))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathSegList.removeItem Mozilla SVGPathSegList.removeItem documentation> 
+removeItemUnsafe ::
+                 (MonadIO m, HasCallStack) => SVGPathSegList -> Word -> m SVGPathSeg
+removeItemUnsafe self index
+  = liftIO
+      ((nullableToMaybe <$> (js_removeItem (self) index)) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathSegList.removeItem Mozilla SVGPathSegList.removeItem documentation> 
 removeItemUnchecked ::
                     (MonadIO m) => SVGPathSegList -> Word -> m SVGPathSeg
 removeItemUnchecked self index
@@ -206,6 +274,17 @@
       (void
          (js_appendItem (self)
             (maybeToNullable (fmap toSVGPathSeg newItem))))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathSegList.appendItem Mozilla SVGPathSegList.appendItem documentation> 
+appendItemUnsafe ::
+                 (MonadIO m, IsSVGPathSeg newItem, HasCallStack) =>
+                   SVGPathSegList -> Maybe newItem -> m SVGPathSeg
+appendItemUnsafe self newItem
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_appendItem (self)
+             (maybeToNullable (fmap toSVGPathSeg newItem))))
+         >>= maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathSegList.appendItem Mozilla SVGPathSegList.appendItem documentation> 
 appendItemUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/SVGPathSegMovetoAbs.hs b/src/GHCJS/DOM/JSFFI/Generated/SVGPathSegMovetoAbs.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/SVGPathSegMovetoAbs.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/SVGPathSegMovetoAbs.hs
@@ -1,10 +1,15 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.SVGPathSegMovetoAbs
        (js_setX, setX, js_getX, getX, js_setY, setY, js_getY, getY,
-        SVGPathSegMovetoAbs, castToSVGPathSegMovetoAbs,
-        gTypeSVGPathSegMovetoAbs)
+        SVGPathSegMovetoAbs(..), gTypeSVGPathSegMovetoAbs)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -20,6 +25,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"x\"] = $2;" js_setX ::
         SVGPathSegMovetoAbs -> Float -> IO ()
diff --git a/src/GHCJS/DOM/JSFFI/Generated/SVGPathSegMovetoRel.hs b/src/GHCJS/DOM/JSFFI/Generated/SVGPathSegMovetoRel.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/SVGPathSegMovetoRel.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/SVGPathSegMovetoRel.hs
@@ -1,10 +1,15 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.SVGPathSegMovetoRel
        (js_setX, setX, js_getX, getX, js_setY, setY, js_getY, getY,
-        SVGPathSegMovetoRel, castToSVGPathSegMovetoRel,
-        gTypeSVGPathSegMovetoRel)
+        SVGPathSegMovetoRel(..), gTypeSVGPathSegMovetoRel)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -20,6 +25,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"x\"] = $2;" js_setX ::
         SVGPathSegMovetoRel -> Float -> IO ()
diff --git a/src/GHCJS/DOM/JSFFI/Generated/SVGPatternElement.hs b/src/GHCJS/DOM/JSFFI/Generated/SVGPatternElement.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/SVGPatternElement.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/SVGPatternElement.hs
@@ -1,14 +1,23 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.SVGPatternElement
-       (js_getPatternUnits, getPatternUnits, getPatternUnitsUnchecked,
-        js_getPatternContentUnits, getPatternContentUnits,
+       (js_getPatternUnits, getPatternUnits, getPatternUnitsUnsafe,
+        getPatternUnitsUnchecked, js_getPatternContentUnits,
+        getPatternContentUnits, getPatternContentUnitsUnsafe,
         getPatternContentUnitsUnchecked, js_getPatternTransform,
-        getPatternTransform, getPatternTransformUnchecked, js_getX, getX,
-        getXUnchecked, js_getY, getY, getYUnchecked, js_getWidth, getWidth,
-        getWidthUnchecked, js_getHeight, getHeight, getHeightUnchecked,
-        SVGPatternElement, castToSVGPatternElement, gTypeSVGPatternElement)
+        getPatternTransform, getPatternTransformUnsafe,
+        getPatternTransformUnchecked, js_getX, getX, getXUnsafe,
+        getXUnchecked, js_getY, getY, getYUnsafe, getYUnchecked,
+        js_getWidth, getWidth, getWidthUnsafe, getWidthUnchecked,
+        js_getHeight, getHeight, getHeightUnsafe, getHeightUnchecked,
+        SVGPatternElement(..), gTypeSVGPatternElement)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -24,6 +33,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"patternUnits\"]"
         js_getPatternUnits ::
@@ -37,6 +56,15 @@
   = liftIO (nullableToMaybe <$> (js_getPatternUnits (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGPatternElement.patternUnits Mozilla SVGPatternElement.patternUnits documentation> 
+getPatternUnitsUnsafe ::
+                      (MonadIO m, HasCallStack) =>
+                        SVGPatternElement -> m SVGAnimatedEnumeration
+getPatternUnitsUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getPatternUnits (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGPatternElement.patternUnits Mozilla SVGPatternElement.patternUnits documentation> 
 getPatternUnitsUnchecked ::
                          (MonadIO m) => SVGPatternElement -> m SVGAnimatedEnumeration
 getPatternUnitsUnchecked self
@@ -55,6 +83,15 @@
   = liftIO (nullableToMaybe <$> (js_getPatternContentUnits (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGPatternElement.patternContentUnits Mozilla SVGPatternElement.patternContentUnits documentation> 
+getPatternContentUnitsUnsafe ::
+                             (MonadIO m, HasCallStack) =>
+                               SVGPatternElement -> m SVGAnimatedEnumeration
+getPatternContentUnitsUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getPatternContentUnits (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGPatternElement.patternContentUnits Mozilla SVGPatternElement.patternContentUnits documentation> 
 getPatternContentUnitsUnchecked ::
                                 (MonadIO m) => SVGPatternElement -> m SVGAnimatedEnumeration
 getPatternContentUnitsUnchecked self
@@ -73,6 +110,15 @@
   = liftIO (nullableToMaybe <$> (js_getPatternTransform (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGPatternElement.patternTransform Mozilla SVGPatternElement.patternTransform documentation> 
+getPatternTransformUnsafe ::
+                          (MonadIO m, HasCallStack) =>
+                            SVGPatternElement -> m SVGAnimatedTransformList
+getPatternTransformUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getPatternTransform (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGPatternElement.patternTransform Mozilla SVGPatternElement.patternTransform documentation> 
 getPatternTransformUnchecked ::
                              (MonadIO m) => SVGPatternElement -> m SVGAnimatedTransformList
 getPatternTransformUnchecked self
@@ -88,6 +134,15 @@
 getX self = liftIO (nullableToMaybe <$> (js_getX (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGPatternElement.x Mozilla SVGPatternElement.x documentation> 
+getXUnsafe ::
+           (MonadIO m, HasCallStack) =>
+             SVGPatternElement -> m SVGAnimatedLength
+getXUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getX (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGPatternElement.x Mozilla SVGPatternElement.x documentation> 
 getXUnchecked ::
               (MonadIO m) => SVGPatternElement -> m SVGAnimatedLength
 getXUnchecked self
@@ -102,6 +157,15 @@
 getY self = liftIO (nullableToMaybe <$> (js_getY (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGPatternElement.y Mozilla SVGPatternElement.y documentation> 
+getYUnsafe ::
+           (MonadIO m, HasCallStack) =>
+             SVGPatternElement -> m SVGAnimatedLength
+getYUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getY (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGPatternElement.y Mozilla SVGPatternElement.y documentation> 
 getYUnchecked ::
               (MonadIO m) => SVGPatternElement -> m SVGAnimatedLength
 getYUnchecked self
@@ -116,6 +180,15 @@
 getWidth self = liftIO (nullableToMaybe <$> (js_getWidth (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGPatternElement.width Mozilla SVGPatternElement.width documentation> 
+getWidthUnsafe ::
+               (MonadIO m, HasCallStack) =>
+                 SVGPatternElement -> m SVGAnimatedLength
+getWidthUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getWidth (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGPatternElement.width Mozilla SVGPatternElement.width documentation> 
 getWidthUnchecked ::
                   (MonadIO m) => SVGPatternElement -> m SVGAnimatedLength
 getWidthUnchecked self
@@ -128,6 +201,15 @@
 getHeight ::
           (MonadIO m) => SVGPatternElement -> m (Maybe SVGAnimatedLength)
 getHeight self = liftIO (nullableToMaybe <$> (js_getHeight (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGPatternElement.height Mozilla SVGPatternElement.height documentation> 
+getHeightUnsafe ::
+                (MonadIO m, HasCallStack) =>
+                  SVGPatternElement -> m SVGAnimatedLength
+getHeightUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getHeight (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGPatternElement.height Mozilla SVGPatternElement.height documentation> 
 getHeightUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/SVGPoint.hs b/src/GHCJS/DOM/JSFFI/Generated/SVGPoint.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/SVGPoint.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/SVGPoint.hs
@@ -1,10 +1,17 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.SVGPoint
        (js_matrixTransform, matrixTransform, matrixTransform_,
-        matrixTransformUnchecked, js_setX, setX, js_getX, getX, js_setY,
-        setY, js_getY, getY, SVGPoint, castToSVGPoint, gTypeSVGPoint)
+        matrixTransformUnsafe, matrixTransformUnchecked, js_setX, setX,
+        js_getX, getX, js_setY, setY, js_getY, getY, SVGPoint(..),
+        gTypeSVGPoint)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -20,6 +27,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"matrixTransform\"]($2)"
         js_matrixTransform ::
@@ -39,6 +56,16 @@
 matrixTransform_ self matrix
   = liftIO
       (void (js_matrixTransform (self) (maybeToNullable matrix)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGPoint.matrixTransform Mozilla SVGPoint.matrixTransform documentation> 
+matrixTransformUnsafe ::
+                      (MonadIO m, HasCallStack) =>
+                        SVGPoint -> Maybe SVGMatrix -> m SVGPoint
+matrixTransformUnsafe self matrix
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_matrixTransform (self) (maybeToNullable matrix)))
+         >>= maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGPoint.matrixTransform Mozilla SVGPoint.matrixTransform documentation> 
 matrixTransformUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/SVGPointList.hs b/src/GHCJS/DOM/JSFFI/Generated/SVGPointList.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/SVGPointList.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/SVGPointList.hs
@@ -1,16 +1,23 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.SVGPointList
        (js_clear, clear, js_initialize, initialize, initialize_,
-        initializeUnchecked, js_getItem, getItem, getItem_,
-        getItemUnchecked, js_insertItemBefore, insertItemBefore,
-        insertItemBefore_, insertItemBeforeUnchecked, js_replaceItem,
-        replaceItem, replaceItem_, replaceItemUnchecked, js_removeItem,
-        removeItem, removeItem_, removeItemUnchecked, js_appendItem,
-        appendItem, appendItem_, appendItemUnchecked, js_getNumberOfItems,
-        getNumberOfItems, SVGPointList, castToSVGPointList,
-        gTypeSVGPointList)
+        initializeUnsafe, initializeUnchecked, js_getItem, getItem,
+        getItem_, getItemUnsafe, getItemUnchecked, js_insertItemBefore,
+        insertItemBefore, insertItemBefore_, insertItemBeforeUnsafe,
+        insertItemBeforeUnchecked, js_replaceItem, replaceItem,
+        replaceItem_, replaceItemUnsafe, replaceItemUnchecked,
+        js_removeItem, removeItem, removeItem_, removeItemUnsafe,
+        removeItemUnchecked, js_appendItem, appendItem, appendItem_,
+        appendItemUnsafe, appendItemUnchecked, js_getNumberOfItems,
+        getNumberOfItems, SVGPointList(..), gTypeSVGPointList)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -26,6 +33,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"clear\"]()" js_clear ::
         SVGPointList -> IO ()
@@ -52,6 +69,16 @@
   = liftIO (void (js_initialize (self) (maybeToNullable item)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGPointList.initialize Mozilla SVGPointList.initialize documentation> 
+initializeUnsafe ::
+                 (MonadIO m, HasCallStack) =>
+                   SVGPointList -> Maybe SVGPoint -> m SVGPoint
+initializeUnsafe self item
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_initialize (self) (maybeToNullable item)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGPointList.initialize Mozilla SVGPointList.initialize documentation> 
 initializeUnchecked ::
                     (MonadIO m) => SVGPointList -> Maybe SVGPoint -> m SVGPoint
 initializeUnchecked self item
@@ -73,6 +100,14 @@
 getItem_ self index = liftIO (void (js_getItem (self) index))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGPointList.getItem Mozilla SVGPointList.getItem documentation> 
+getItemUnsafe ::
+              (MonadIO m, HasCallStack) => SVGPointList -> Word -> m SVGPoint
+getItemUnsafe self index
+  = liftIO
+      ((nullableToMaybe <$> (js_getItem (self) index)) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGPointList.getItem Mozilla SVGPointList.getItem documentation> 
 getItemUnchecked ::
                  (MonadIO m) => SVGPointList -> Word -> m SVGPoint
 getItemUnchecked self index
@@ -99,6 +134,16 @@
       (void (js_insertItemBefore (self) (maybeToNullable item) index))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGPointList.insertItemBefore Mozilla SVGPointList.insertItemBefore documentation> 
+insertItemBeforeUnsafe ::
+                       (MonadIO m, HasCallStack) =>
+                         SVGPointList -> Maybe SVGPoint -> Word -> m SVGPoint
+insertItemBeforeUnsafe self item index
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_insertItemBefore (self) (maybeToNullable item) index))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGPointList.insertItemBefore Mozilla SVGPointList.insertItemBefore documentation> 
 insertItemBeforeUnchecked ::
                           (MonadIO m) => SVGPointList -> Maybe SVGPoint -> Word -> m SVGPoint
 insertItemBeforeUnchecked self item index
@@ -127,6 +172,16 @@
       (void (js_replaceItem (self) (maybeToNullable item) index))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGPointList.replaceItem Mozilla SVGPointList.replaceItem documentation> 
+replaceItemUnsafe ::
+                  (MonadIO m, HasCallStack) =>
+                    SVGPointList -> Maybe SVGPoint -> Word -> m SVGPoint
+replaceItemUnsafe self item index
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_replaceItem (self) (maybeToNullable item) index))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGPointList.replaceItem Mozilla SVGPointList.replaceItem documentation> 
 replaceItemUnchecked ::
                      (MonadIO m) => SVGPointList -> Maybe SVGPoint -> Word -> m SVGPoint
 replaceItemUnchecked self item index
@@ -148,6 +203,14 @@
 removeItem_ self index = liftIO (void (js_removeItem (self) index))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGPointList.removeItem Mozilla SVGPointList.removeItem documentation> 
+removeItemUnsafe ::
+                 (MonadIO m, HasCallStack) => SVGPointList -> Word -> m SVGPoint
+removeItemUnsafe self index
+  = liftIO
+      ((nullableToMaybe <$> (js_removeItem (self) index)) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGPointList.removeItem Mozilla SVGPointList.removeItem documentation> 
 removeItemUnchecked ::
                     (MonadIO m) => SVGPointList -> Word -> m SVGPoint
 removeItemUnchecked self index
@@ -170,6 +233,16 @@
             (MonadIO m) => SVGPointList -> Maybe SVGPoint -> m ()
 appendItem_ self item
   = liftIO (void (js_appendItem (self) (maybeToNullable item)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGPointList.appendItem Mozilla SVGPointList.appendItem documentation> 
+appendItemUnsafe ::
+                 (MonadIO m, HasCallStack) =>
+                   SVGPointList -> Maybe SVGPoint -> m SVGPoint
+appendItemUnsafe self item
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_appendItem (self) (maybeToNullable item)))
+         >>= maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGPointList.appendItem Mozilla SVGPointList.appendItem documentation> 
 appendItemUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/SVGPolygonElement.hs b/src/GHCJS/DOM/JSFFI/Generated/SVGPolygonElement.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/SVGPolygonElement.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/SVGPolygonElement.hs
@@ -1,10 +1,17 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.SVGPolygonElement
-       (js_getPoints, getPoints, getPointsUnchecked, js_getAnimatedPoints,
-        getAnimatedPoints, getAnimatedPointsUnchecked, SVGPolygonElement,
-        castToSVGPolygonElement, gTypeSVGPolygonElement)
+       (js_getPoints, getPoints, getPointsUnsafe, getPointsUnchecked,
+        js_getAnimatedPoints, getAnimatedPoints, getAnimatedPointsUnsafe,
+        getAnimatedPointsUnchecked, SVGPolygonElement(..),
+        gTypeSVGPolygonElement)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -20,6 +27,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"points\"]" js_getPoints ::
         SVGPolygonElement -> IO (Nullable SVGPointList)
@@ -30,6 +47,14 @@
 getPoints self = liftIO (nullableToMaybe <$> (js_getPoints (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGPolygonElement.points Mozilla SVGPolygonElement.points documentation> 
+getPointsUnsafe ::
+                (MonadIO m, HasCallStack) => SVGPolygonElement -> m SVGPointList
+getPointsUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getPoints (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGPolygonElement.points Mozilla SVGPolygonElement.points documentation> 
 getPointsUnchecked ::
                    (MonadIO m) => SVGPolygonElement -> m SVGPointList
 getPointsUnchecked self
@@ -44,6 +69,14 @@
                   (MonadIO m) => SVGPolygonElement -> m (Maybe SVGPointList)
 getAnimatedPoints self
   = liftIO (nullableToMaybe <$> (js_getAnimatedPoints (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGPolygonElement.animatedPoints Mozilla SVGPolygonElement.animatedPoints documentation> 
+getAnimatedPointsUnsafe ::
+                        (MonadIO m, HasCallStack) => SVGPolygonElement -> m SVGPointList
+getAnimatedPointsUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getAnimatedPoints (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGPolygonElement.animatedPoints Mozilla SVGPolygonElement.animatedPoints documentation> 
 getAnimatedPointsUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/SVGPolylineElement.hs b/src/GHCJS/DOM/JSFFI/Generated/SVGPolylineElement.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/SVGPolylineElement.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/SVGPolylineElement.hs
@@ -1,10 +1,17 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.SVGPolylineElement
-       (js_getPoints, getPoints, getPointsUnchecked, js_getAnimatedPoints,
-        getAnimatedPoints, getAnimatedPointsUnchecked, SVGPolylineElement,
-        castToSVGPolylineElement, gTypeSVGPolylineElement)
+       (js_getPoints, getPoints, getPointsUnsafe, getPointsUnchecked,
+        js_getAnimatedPoints, getAnimatedPoints, getAnimatedPointsUnsafe,
+        getAnimatedPointsUnchecked, SVGPolylineElement(..),
+        gTypeSVGPolylineElement)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -20,6 +27,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"points\"]" js_getPoints ::
         SVGPolylineElement -> IO (Nullable SVGPointList)
@@ -30,6 +47,14 @@
 getPoints self = liftIO (nullableToMaybe <$> (js_getPoints (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGPolylineElement.points Mozilla SVGPolylineElement.points documentation> 
+getPointsUnsafe ::
+                (MonadIO m, HasCallStack) => SVGPolylineElement -> m SVGPointList
+getPointsUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getPoints (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGPolylineElement.points Mozilla SVGPolylineElement.points documentation> 
 getPointsUnchecked ::
                    (MonadIO m) => SVGPolylineElement -> m SVGPointList
 getPointsUnchecked self
@@ -44,6 +69,14 @@
                   (MonadIO m) => SVGPolylineElement -> m (Maybe SVGPointList)
 getAnimatedPoints self
   = liftIO (nullableToMaybe <$> (js_getAnimatedPoints (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGPolylineElement.animatedPoints Mozilla SVGPolylineElement.animatedPoints documentation> 
+getAnimatedPointsUnsafe ::
+                        (MonadIO m, HasCallStack) => SVGPolylineElement -> m SVGPointList
+getAnimatedPointsUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getAnimatedPoints (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGPolylineElement.animatedPoints Mozilla SVGPolylineElement.animatedPoints documentation> 
 getAnimatedPointsUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/SVGPreserveAspectRatio.hs b/src/GHCJS/DOM/JSFFI/Generated/SVGPreserveAspectRatio.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/SVGPreserveAspectRatio.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/SVGPreserveAspectRatio.hs
@@ -1,4 +1,9 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.SVGPreserveAspectRatio
        (pattern SVG_PRESERVEASPECTRATIO_UNKNOWN,
         pattern SVG_PRESERVEASPECTRATIO_NONE,
@@ -14,10 +19,11 @@
         pattern SVG_MEETORSLICE_UNKNOWN, pattern SVG_MEETORSLICE_MEET,
         pattern SVG_MEETORSLICE_SLICE, js_setAlign, setAlign, js_getAlign,
         getAlign, js_setMeetOrSlice, setMeetOrSlice, js_getMeetOrSlice,
-        getMeetOrSlice, SVGPreserveAspectRatio,
-        castToSVGPreserveAspectRatio, gTypeSVGPreserveAspectRatio)
+        getMeetOrSlice, SVGPreserveAspectRatio(..),
+        gTypeSVGPreserveAspectRatio)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -33,6 +39,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
 pattern SVG_PRESERVEASPECTRATIO_UNKNOWN = 0
 pattern SVG_PRESERVEASPECTRATIO_NONE = 1
 pattern SVG_PRESERVEASPECTRATIO_XMINYMIN = 2
diff --git a/src/GHCJS/DOM/JSFFI/Generated/SVGRadialGradientElement.hs b/src/GHCJS/DOM/JSFFI/Generated/SVGRadialGradientElement.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/SVGRadialGradientElement.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/SVGRadialGradientElement.hs
@@ -1,12 +1,19 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.SVGRadialGradientElement
-       (js_getCx, getCx, getCxUnchecked, js_getCy, getCy, getCyUnchecked,
-        js_getR, getR, getRUnchecked, js_getFx, getFx, getFxUnchecked,
-        js_getFy, getFy, getFyUnchecked, js_getFr, getFr, getFrUnchecked,
-        SVGRadialGradientElement, castToSVGRadialGradientElement,
+       (js_getCx, getCx, getCxUnsafe, getCxUnchecked, js_getCy, getCy,
+        getCyUnsafe, getCyUnchecked, js_getR, getR, getRUnsafe,
+        getRUnchecked, js_getFx, getFx, getFxUnsafe, getFxUnchecked,
+        js_getFy, getFy, getFyUnsafe, getFyUnchecked, js_getFr, getFr,
+        getFrUnsafe, getFrUnchecked, SVGRadialGradientElement(..),
         gTypeSVGRadialGradientElement)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -22,6 +29,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"cx\"]" js_getCx ::
         SVGRadialGradientElement -> IO (Nullable SVGAnimatedLength)
@@ -33,6 +50,15 @@
 getCx self = liftIO (nullableToMaybe <$> (js_getCx (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGRadialGradientElement.cx Mozilla SVGRadialGradientElement.cx documentation> 
+getCxUnsafe ::
+            (MonadIO m, HasCallStack) =>
+              SVGRadialGradientElement -> m SVGAnimatedLength
+getCxUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getCx (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGRadialGradientElement.cx Mozilla SVGRadialGradientElement.cx documentation> 
 getCxUnchecked ::
                (MonadIO m) => SVGRadialGradientElement -> m SVGAnimatedLength
 getCxUnchecked self
@@ -48,6 +74,15 @@
 getCy self = liftIO (nullableToMaybe <$> (js_getCy (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGRadialGradientElement.cy Mozilla SVGRadialGradientElement.cy documentation> 
+getCyUnsafe ::
+            (MonadIO m, HasCallStack) =>
+              SVGRadialGradientElement -> m SVGAnimatedLength
+getCyUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getCy (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGRadialGradientElement.cy Mozilla SVGRadialGradientElement.cy documentation> 
 getCyUnchecked ::
                (MonadIO m) => SVGRadialGradientElement -> m SVGAnimatedLength
 getCyUnchecked self
@@ -63,6 +98,15 @@
 getR self = liftIO (nullableToMaybe <$> (js_getR (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGRadialGradientElement.r Mozilla SVGRadialGradientElement.r documentation> 
+getRUnsafe ::
+           (MonadIO m, HasCallStack) =>
+             SVGRadialGradientElement -> m SVGAnimatedLength
+getRUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getR (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGRadialGradientElement.r Mozilla SVGRadialGradientElement.r documentation> 
 getRUnchecked ::
               (MonadIO m) => SVGRadialGradientElement -> m SVGAnimatedLength
 getRUnchecked self
@@ -78,6 +122,15 @@
 getFx self = liftIO (nullableToMaybe <$> (js_getFx (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGRadialGradientElement.fx Mozilla SVGRadialGradientElement.fx documentation> 
+getFxUnsafe ::
+            (MonadIO m, HasCallStack) =>
+              SVGRadialGradientElement -> m SVGAnimatedLength
+getFxUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getFx (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGRadialGradientElement.fx Mozilla SVGRadialGradientElement.fx documentation> 
 getFxUnchecked ::
                (MonadIO m) => SVGRadialGradientElement -> m SVGAnimatedLength
 getFxUnchecked self
@@ -93,6 +146,15 @@
 getFy self = liftIO (nullableToMaybe <$> (js_getFy (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGRadialGradientElement.fy Mozilla SVGRadialGradientElement.fy documentation> 
+getFyUnsafe ::
+            (MonadIO m, HasCallStack) =>
+              SVGRadialGradientElement -> m SVGAnimatedLength
+getFyUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getFy (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGRadialGradientElement.fy Mozilla SVGRadialGradientElement.fy documentation> 
 getFyUnchecked ::
                (MonadIO m) => SVGRadialGradientElement -> m SVGAnimatedLength
 getFyUnchecked self
@@ -106,6 +168,15 @@
       (MonadIO m) =>
         SVGRadialGradientElement -> m (Maybe SVGAnimatedLength)
 getFr self = liftIO (nullableToMaybe <$> (js_getFr (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGRadialGradientElement.fr Mozilla SVGRadialGradientElement.fr documentation> 
+getFrUnsafe ::
+            (MonadIO m, HasCallStack) =>
+              SVGRadialGradientElement -> m SVGAnimatedLength
+getFrUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getFr (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGRadialGradientElement.fr Mozilla SVGRadialGradientElement.fr documentation> 
 getFrUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/SVGRect.hs b/src/GHCJS/DOM/JSFFI/Generated/SVGRect.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/SVGRect.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/SVGRect.hs
@@ -1,11 +1,16 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.SVGRect
        (js_setX, setX, js_getX, getX, js_setY, setY, js_getY, getY,
         js_setWidth, setWidth, js_getWidth, getWidth, js_setHeight,
-        setHeight, js_getHeight, getHeight, SVGRect, castToSVGRect,
-        gTypeSVGRect)
+        setHeight, js_getHeight, getHeight, SVGRect(..), gTypeSVGRect)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -21,6 +26,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"x\"] = $2;" js_setX ::
         SVGRect -> Float -> IO ()
diff --git a/src/GHCJS/DOM/JSFFI/Generated/SVGRectElement.hs b/src/GHCJS/DOM/JSFFI/Generated/SVGRectElement.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/SVGRectElement.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/SVGRectElement.hs
@@ -1,12 +1,19 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.SVGRectElement
-       (js_getX, getX, getXUnchecked, js_getY, getY, getYUnchecked,
-        js_getWidth, getWidth, getWidthUnchecked, js_getHeight, getHeight,
-        getHeightUnchecked, js_getRx, getRx, getRxUnchecked, js_getRy,
-        getRy, getRyUnchecked, SVGRectElement, castToSVGRectElement,
+       (js_getX, getX, getXUnsafe, getXUnchecked, js_getY, getY,
+        getYUnsafe, getYUnchecked, js_getWidth, getWidth, getWidthUnsafe,
+        getWidthUnchecked, js_getHeight, getHeight, getHeightUnsafe,
+        getHeightUnchecked, js_getRx, getRx, getRxUnsafe, getRxUnchecked,
+        js_getRy, getRy, getRyUnsafe, getRyUnchecked, SVGRectElement(..),
         gTypeSVGRectElement)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -22,6 +29,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"x\"]" js_getX ::
         SVGRectElement -> IO (Nullable SVGAnimatedLength)
@@ -32,6 +49,14 @@
 getX self = liftIO (nullableToMaybe <$> (js_getX (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGRectElement.x Mozilla SVGRectElement.x documentation> 
+getXUnsafe ::
+           (MonadIO m, HasCallStack) => SVGRectElement -> m SVGAnimatedLength
+getXUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getX (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGRectElement.x Mozilla SVGRectElement.x documentation> 
 getXUnchecked ::
               (MonadIO m) => SVGRectElement -> m SVGAnimatedLength
 getXUnchecked self
@@ -46,6 +71,14 @@
 getY self = liftIO (nullableToMaybe <$> (js_getY (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGRectElement.y Mozilla SVGRectElement.y documentation> 
+getYUnsafe ::
+           (MonadIO m, HasCallStack) => SVGRectElement -> m SVGAnimatedLength
+getYUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getY (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGRectElement.y Mozilla SVGRectElement.y documentation> 
 getYUnchecked ::
               (MonadIO m) => SVGRectElement -> m SVGAnimatedLength
 getYUnchecked self
@@ -60,6 +93,14 @@
 getWidth self = liftIO (nullableToMaybe <$> (js_getWidth (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGRectElement.width Mozilla SVGRectElement.width documentation> 
+getWidthUnsafe ::
+               (MonadIO m, HasCallStack) => SVGRectElement -> m SVGAnimatedLength
+getWidthUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getWidth (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGRectElement.width Mozilla SVGRectElement.width documentation> 
 getWidthUnchecked ::
                   (MonadIO m) => SVGRectElement -> m SVGAnimatedLength
 getWidthUnchecked self
@@ -74,6 +115,14 @@
 getHeight self = liftIO (nullableToMaybe <$> (js_getHeight (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGRectElement.height Mozilla SVGRectElement.height documentation> 
+getHeightUnsafe ::
+                (MonadIO m, HasCallStack) => SVGRectElement -> m SVGAnimatedLength
+getHeightUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getHeight (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGRectElement.height Mozilla SVGRectElement.height documentation> 
 getHeightUnchecked ::
                    (MonadIO m) => SVGRectElement -> m SVGAnimatedLength
 getHeightUnchecked self
@@ -88,6 +137,14 @@
 getRx self = liftIO (nullableToMaybe <$> (js_getRx (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGRectElement.rx Mozilla SVGRectElement.rx documentation> 
+getRxUnsafe ::
+            (MonadIO m, HasCallStack) => SVGRectElement -> m SVGAnimatedLength
+getRxUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getRx (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGRectElement.rx Mozilla SVGRectElement.rx documentation> 
 getRxUnchecked ::
                (MonadIO m) => SVGRectElement -> m SVGAnimatedLength
 getRxUnchecked self
@@ -100,6 +157,14 @@
 getRy ::
       (MonadIO m) => SVGRectElement -> m (Maybe SVGAnimatedLength)
 getRy self = liftIO (nullableToMaybe <$> (js_getRy (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGRectElement.ry Mozilla SVGRectElement.ry documentation> 
+getRyUnsafe ::
+            (MonadIO m, HasCallStack) => SVGRectElement -> m SVGAnimatedLength
+getRyUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getRy (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGRectElement.ry Mozilla SVGRectElement.ry documentation> 
 getRyUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/SVGRenderingIntent.hs b/src/GHCJS/DOM/JSFFI/Generated/SVGRenderingIntent.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/SVGRenderingIntent.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/SVGRenderingIntent.hs
@@ -1,13 +1,19 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.SVGRenderingIntent
        (pattern RENDERING_INTENT_UNKNOWN, pattern RENDERING_INTENT_AUTO,
         pattern RENDERING_INTENT_PERCEPTUAL,
         pattern RENDERING_INTENT_RELATIVE_COLORIMETRIC,
         pattern RENDERING_INTENT_SATURATION,
-        pattern RENDERING_INTENT_ABSOLUTE_COLORIMETRIC, SVGRenderingIntent,
-        castToSVGRenderingIntent, gTypeSVGRenderingIntent)
+        pattern RENDERING_INTENT_ABSOLUTE_COLORIMETRIC,
+        SVGRenderingIntent(..), gTypeSVGRenderingIntent)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -23,6 +29,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
 pattern RENDERING_INTENT_UNKNOWN = 0
 pattern RENDERING_INTENT_AUTO = 1
 pattern RENDERING_INTENT_PERCEPTUAL = 2
diff --git a/src/GHCJS/DOM/JSFFI/Generated/SVGSVGElement.hs b/src/GHCJS/DOM/JSFFI/Generated/SVGSVGElement.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/SVGSVGElement.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/SVGSVGElement.hs
@@ -1,4 +1,9 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.SVGSVGElement
        (js_suspendRedraw, suspendRedraw, suspendRedraw_,
         js_unsuspendRedraw, unsuspendRedraw, js_unsuspendRedrawAll,
@@ -8,41 +13,49 @@
         animationsPaused_, js_getCurrentTime, getCurrentTime,
         getCurrentTime_, js_setCurrentTime, setCurrentTime,
         js_getIntersectionList, getIntersectionList, getIntersectionList_,
-        getIntersectionListUnchecked, js_getEnclosureList,
-        getEnclosureList, getEnclosureList_, getEnclosureListUnchecked,
+        getIntersectionListUnsafe, getIntersectionListUnchecked,
+        js_getEnclosureList, getEnclosureList, getEnclosureList_,
+        getEnclosureListUnsafe, getEnclosureListUnchecked,
         js_checkIntersection, checkIntersection, checkIntersection_,
         js_checkEnclosure, checkEnclosure, checkEnclosure_, js_deselectAll,
         deselectAll, js_createSVGNumber, createSVGNumber, createSVGNumber_,
-        createSVGNumberUnchecked, js_createSVGLength, createSVGLength,
-        createSVGLength_, createSVGLengthUnchecked, js_createSVGAngle,
-        createSVGAngle, createSVGAngle_, createSVGAngleUnchecked,
-        js_createSVGPoint, createSVGPoint, createSVGPoint_,
-        createSVGPointUnchecked, js_createSVGMatrix, createSVGMatrix,
-        createSVGMatrix_, createSVGMatrixUnchecked, js_createSVGRect,
-        createSVGRect, createSVGRect_, createSVGRectUnchecked,
-        js_createSVGTransform, createSVGTransform, createSVGTransform_,
+        createSVGNumberUnsafe, createSVGNumberUnchecked,
+        js_createSVGLength, createSVGLength, createSVGLength_,
+        createSVGLengthUnsafe, createSVGLengthUnchecked, js_createSVGAngle,
+        createSVGAngle, createSVGAngle_, createSVGAngleUnsafe,
+        createSVGAngleUnchecked, js_createSVGPoint, createSVGPoint,
+        createSVGPoint_, createSVGPointUnsafe, createSVGPointUnchecked,
+        js_createSVGMatrix, createSVGMatrix, createSVGMatrix_,
+        createSVGMatrixUnsafe, createSVGMatrixUnchecked, js_createSVGRect,
+        createSVGRect, createSVGRect_, createSVGRectUnsafe,
+        createSVGRectUnchecked, js_createSVGTransform, createSVGTransform,
+        createSVGTransform_, createSVGTransformUnsafe,
         createSVGTransformUnchecked, js_createSVGTransformFromMatrix,
         createSVGTransformFromMatrix, createSVGTransformFromMatrix_,
+        createSVGTransformFromMatrixUnsafe,
         createSVGTransformFromMatrixUnchecked, js_getElementById,
-        getElementById, getElementById_, getElementByIdUnchecked, js_getX,
-        getX, getXUnchecked, js_getY, getY, getYUnchecked, js_getWidth,
-        getWidth, getWidthUnchecked, js_getHeight, getHeight,
-        getHeightUnchecked, js_setContentScriptType, setContentScriptType,
-        js_getContentScriptType, getContentScriptType,
-        js_setContentStyleType, setContentStyleType,
+        getElementById, getElementById_, getElementByIdUnsafe,
+        getElementByIdUnchecked, js_getX, getX, getXUnsafe, getXUnchecked,
+        js_getY, getY, getYUnsafe, getYUnchecked, js_getWidth, getWidth,
+        getWidthUnsafe, getWidthUnchecked, js_getHeight, getHeight,
+        getHeightUnsafe, getHeightUnchecked, js_setContentScriptType,
+        setContentScriptType, js_getContentScriptType,
+        getContentScriptType, js_setContentStyleType, setContentStyleType,
         js_getContentStyleType, getContentStyleType, js_getViewport,
-        getViewport, getViewportUnchecked, js_getPixelUnitToMillimeterX,
-        getPixelUnitToMillimeterX, js_getPixelUnitToMillimeterY,
-        getPixelUnitToMillimeterY, js_getScreenPixelToMillimeterX,
-        getScreenPixelToMillimeterX, js_getScreenPixelToMillimeterY,
-        getScreenPixelToMillimeterY, js_getUseCurrentView,
-        getUseCurrentView, js_getCurrentView, getCurrentView,
-        getCurrentViewUnchecked, js_setCurrentScale, setCurrentScale,
-        js_getCurrentScale, getCurrentScale, js_getCurrentTranslate,
-        getCurrentTranslate, getCurrentTranslateUnchecked, SVGSVGElement,
-        castToSVGSVGElement, gTypeSVGSVGElement)
+        getViewport, getViewportUnsafe, getViewportUnchecked,
+        js_getPixelUnitToMillimeterX, getPixelUnitToMillimeterX,
+        js_getPixelUnitToMillimeterY, getPixelUnitToMillimeterY,
+        js_getScreenPixelToMillimeterX, getScreenPixelToMillimeterX,
+        js_getScreenPixelToMillimeterY, getScreenPixelToMillimeterY,
+        js_getUseCurrentView, getUseCurrentView, js_getCurrentView,
+        getCurrentView, getCurrentViewUnsafe, getCurrentViewUnchecked,
+        js_setCurrentScale, setCurrentScale, js_getCurrentScale,
+        getCurrentScale, js_getCurrentTranslate, getCurrentTranslate,
+        getCurrentTranslateUnsafe, getCurrentTranslateUnchecked,
+        SVGSVGElement(..), gTypeSVGSVGElement)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -58,6 +71,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"suspendRedraw\"]($2)"
         js_suspendRedraw :: SVGSVGElement -> Word -> IO Word
@@ -166,6 +189,18 @@
             (maybeToNullable (fmap toSVGElement referenceElement))))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGSVGElement.getIntersectionList Mozilla SVGSVGElement.getIntersectionList documentation> 
+getIntersectionListUnsafe ::
+                          (MonadIO m, IsSVGElement referenceElement, HasCallStack) =>
+                            SVGSVGElement ->
+                              Maybe SVGRect -> Maybe referenceElement -> m NodeList
+getIntersectionListUnsafe self rect referenceElement
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_getIntersectionList (self) (maybeToNullable rect)
+             (maybeToNullable (fmap toSVGElement referenceElement))))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGSVGElement.getIntersectionList Mozilla SVGSVGElement.getIntersectionList documentation> 
 getIntersectionListUnchecked ::
                              (MonadIO m, IsSVGElement referenceElement) =>
                                SVGSVGElement ->
@@ -203,6 +238,18 @@
             (maybeToNullable (fmap toSVGElement referenceElement))))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGSVGElement.getEnclosureList Mozilla SVGSVGElement.getEnclosureList documentation> 
+getEnclosureListUnsafe ::
+                       (MonadIO m, IsSVGElement referenceElement, HasCallStack) =>
+                         SVGSVGElement ->
+                           Maybe SVGRect -> Maybe referenceElement -> m NodeList
+getEnclosureListUnsafe self rect referenceElement
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_getEnclosureList (self) (maybeToNullable rect)
+             (maybeToNullable (fmap toSVGElement referenceElement))))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGSVGElement.getEnclosureList Mozilla SVGSVGElement.getEnclosureList documentation> 
 getEnclosureListUnchecked ::
                           (MonadIO m, IsSVGElement referenceElement) =>
                             SVGSVGElement ->
@@ -285,6 +332,14 @@
 createSVGNumber_ self = liftIO (void (js_createSVGNumber (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGSVGElement.createSVGNumber Mozilla SVGSVGElement.createSVGNumber documentation> 
+createSVGNumberUnsafe ::
+                      (MonadIO m, HasCallStack) => SVGSVGElement -> m SVGNumber
+createSVGNumberUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_createSVGNumber (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGSVGElement.createSVGNumber Mozilla SVGSVGElement.createSVGNumber documentation> 
 createSVGNumberUnchecked ::
                          (MonadIO m) => SVGSVGElement -> m SVGNumber
 createSVGNumberUnchecked self
@@ -305,6 +360,14 @@
 createSVGLength_ self = liftIO (void (js_createSVGLength (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGSVGElement.createSVGLength Mozilla SVGSVGElement.createSVGLength documentation> 
+createSVGLengthUnsafe ::
+                      (MonadIO m, HasCallStack) => SVGSVGElement -> m SVGLength
+createSVGLengthUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_createSVGLength (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGSVGElement.createSVGLength Mozilla SVGSVGElement.createSVGLength documentation> 
 createSVGLengthUnchecked ::
                          (MonadIO m) => SVGSVGElement -> m SVGLength
 createSVGLengthUnchecked self
@@ -325,6 +388,14 @@
 createSVGAngle_ self = liftIO (void (js_createSVGAngle (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGSVGElement.createSVGAngle Mozilla SVGSVGElement.createSVGAngle documentation> 
+createSVGAngleUnsafe ::
+                     (MonadIO m, HasCallStack) => SVGSVGElement -> m SVGAngle
+createSVGAngleUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_createSVGAngle (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGSVGElement.createSVGAngle Mozilla SVGSVGElement.createSVGAngle documentation> 
 createSVGAngleUnchecked ::
                         (MonadIO m) => SVGSVGElement -> m SVGAngle
 createSVGAngleUnchecked self
@@ -345,6 +416,14 @@
 createSVGPoint_ self = liftIO (void (js_createSVGPoint (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGSVGElement.createSVGPoint Mozilla SVGSVGElement.createSVGPoint documentation> 
+createSVGPointUnsafe ::
+                     (MonadIO m, HasCallStack) => SVGSVGElement -> m SVGPoint
+createSVGPointUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_createSVGPoint (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGSVGElement.createSVGPoint Mozilla SVGSVGElement.createSVGPoint documentation> 
 createSVGPointUnchecked ::
                         (MonadIO m) => SVGSVGElement -> m SVGPoint
 createSVGPointUnchecked self
@@ -365,6 +444,14 @@
 createSVGMatrix_ self = liftIO (void (js_createSVGMatrix (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGSVGElement.createSVGMatrix Mozilla SVGSVGElement.createSVGMatrix documentation> 
+createSVGMatrixUnsafe ::
+                      (MonadIO m, HasCallStack) => SVGSVGElement -> m SVGMatrix
+createSVGMatrixUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_createSVGMatrix (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGSVGElement.createSVGMatrix Mozilla SVGSVGElement.createSVGMatrix documentation> 
 createSVGMatrixUnchecked ::
                          (MonadIO m) => SVGSVGElement -> m SVGMatrix
 createSVGMatrixUnchecked self
@@ -384,6 +471,14 @@
 createSVGRect_ self = liftIO (void (js_createSVGRect (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGSVGElement.createSVGRect Mozilla SVGSVGElement.createSVGRect documentation> 
+createSVGRectUnsafe ::
+                    (MonadIO m, HasCallStack) => SVGSVGElement -> m SVGRect
+createSVGRectUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_createSVGRect (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGSVGElement.createSVGRect Mozilla SVGSVGElement.createSVGRect documentation> 
 createSVGRectUnchecked :: (MonadIO m) => SVGSVGElement -> m SVGRect
 createSVGRectUnchecked self
   = liftIO (fromJust . nullableToMaybe <$> (js_createSVGRect (self)))
@@ -404,6 +499,14 @@
   = liftIO (void (js_createSVGTransform (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGSVGElement.createSVGTransform Mozilla SVGSVGElement.createSVGTransform documentation> 
+createSVGTransformUnsafe ::
+                         (MonadIO m, HasCallStack) => SVGSVGElement -> m SVGTransform
+createSVGTransformUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_createSVGTransform (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGSVGElement.createSVGTransform Mozilla SVGSVGElement.createSVGTransform documentation> 
 createSVGTransformUnchecked ::
                             (MonadIO m) => SVGSVGElement -> m SVGTransform
 createSVGTransformUnchecked self
@@ -433,6 +536,16 @@
          (js_createSVGTransformFromMatrix (self) (maybeToNullable matrix)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGSVGElement.createSVGTransformFromMatrix Mozilla SVGSVGElement.createSVGTransformFromMatrix documentation> 
+createSVGTransformFromMatrixUnsafe ::
+                                   (MonadIO m, HasCallStack) =>
+                                     SVGSVGElement -> Maybe SVGMatrix -> m SVGTransform
+createSVGTransformFromMatrixUnsafe self matrix
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_createSVGTransformFromMatrix (self) (maybeToNullable matrix)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGSVGElement.createSVGTransformFromMatrix Mozilla SVGSVGElement.createSVGTransformFromMatrix documentation> 
 createSVGTransformFromMatrixUnchecked ::
                                       (MonadIO m) =>
                                         SVGSVGElement -> Maybe SVGMatrix -> m SVGTransform
@@ -462,6 +575,16 @@
   = liftIO (void (js_getElementById (self) (toJSString elementId)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGSVGElement.getElementById Mozilla SVGSVGElement.getElementById documentation> 
+getElementByIdUnsafe ::
+                     (MonadIO m, ToJSString elementId, HasCallStack) =>
+                       SVGSVGElement -> elementId -> m Element
+getElementByIdUnsafe self elementId
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_getElementById (self) (toJSString elementId)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGSVGElement.getElementById Mozilla SVGSVGElement.getElementById documentation> 
 getElementByIdUnchecked ::
                         (MonadIO m, ToJSString elementId) =>
                           SVGSVGElement -> elementId -> m Element
@@ -478,6 +601,14 @@
 getX self = liftIO (nullableToMaybe <$> (js_getX (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGSVGElement.x Mozilla SVGSVGElement.x documentation> 
+getXUnsafe ::
+           (MonadIO m, HasCallStack) => SVGSVGElement -> m SVGAnimatedLength
+getXUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getX (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGSVGElement.x Mozilla SVGSVGElement.x documentation> 
 getXUnchecked ::
               (MonadIO m) => SVGSVGElement -> m SVGAnimatedLength
 getXUnchecked self
@@ -491,6 +622,14 @@
 getY self = liftIO (nullableToMaybe <$> (js_getY (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGSVGElement.y Mozilla SVGSVGElement.y documentation> 
+getYUnsafe ::
+           (MonadIO m, HasCallStack) => SVGSVGElement -> m SVGAnimatedLength
+getYUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getY (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGSVGElement.y Mozilla SVGSVGElement.y documentation> 
 getYUnchecked ::
               (MonadIO m) => SVGSVGElement -> m SVGAnimatedLength
 getYUnchecked self
@@ -505,6 +644,14 @@
 getWidth self = liftIO (nullableToMaybe <$> (js_getWidth (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGSVGElement.width Mozilla SVGSVGElement.width documentation> 
+getWidthUnsafe ::
+               (MonadIO m, HasCallStack) => SVGSVGElement -> m SVGAnimatedLength
+getWidthUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getWidth (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGSVGElement.width Mozilla SVGSVGElement.width documentation> 
 getWidthUnchecked ::
                   (MonadIO m) => SVGSVGElement -> m SVGAnimatedLength
 getWidthUnchecked self
@@ -519,6 +666,14 @@
 getHeight self = liftIO (nullableToMaybe <$> (js_getHeight (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGSVGElement.height Mozilla SVGSVGElement.height documentation> 
+getHeightUnsafe ::
+                (MonadIO m, HasCallStack) => SVGSVGElement -> m SVGAnimatedLength
+getHeightUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getHeight (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGSVGElement.height Mozilla SVGSVGElement.height documentation> 
 getHeightUnchecked ::
                    (MonadIO m) => SVGSVGElement -> m SVGAnimatedLength
 getHeightUnchecked self
@@ -569,6 +724,14 @@
   = liftIO (nullableToMaybe <$> (js_getViewport (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGSVGElement.viewport Mozilla SVGSVGElement.viewport documentation> 
+getViewportUnsafe ::
+                  (MonadIO m, HasCallStack) => SVGSVGElement -> m SVGRect
+getViewportUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getViewport (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGSVGElement.viewport Mozilla SVGSVGElement.viewport documentation> 
 getViewportUnchecked :: (MonadIO m) => SVGSVGElement -> m SVGRect
 getViewportUnchecked self
   = liftIO (fromJust . nullableToMaybe <$> (js_getViewport (self)))
@@ -626,6 +789,14 @@
   = liftIO (nullableToMaybe <$> (js_getCurrentView (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGSVGElement.currentView Mozilla SVGSVGElement.currentView documentation> 
+getCurrentViewUnsafe ::
+                     (MonadIO m, HasCallStack) => SVGSVGElement -> m SVGViewSpec
+getCurrentViewUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getCurrentView (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGSVGElement.currentView Mozilla SVGSVGElement.currentView documentation> 
 getCurrentViewUnchecked ::
                         (MonadIO m) => SVGSVGElement -> m SVGViewSpec
 getCurrentViewUnchecked self
@@ -654,6 +825,14 @@
                     (MonadIO m) => SVGSVGElement -> m (Maybe SVGPoint)
 getCurrentTranslate self
   = liftIO (nullableToMaybe <$> (js_getCurrentTranslate (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGSVGElement.currentTranslate Mozilla SVGSVGElement.currentTranslate documentation> 
+getCurrentTranslateUnsafe ::
+                          (MonadIO m, HasCallStack) => SVGSVGElement -> m SVGPoint
+getCurrentTranslateUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getCurrentTranslate (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGSVGElement.currentTranslate Mozilla SVGSVGElement.currentTranslate documentation> 
 getCurrentTranslateUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/SVGScriptElement.hs b/src/GHCJS/DOM/JSFFI/Generated/SVGScriptElement.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/SVGScriptElement.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/SVGScriptElement.hs
@@ -1,9 +1,15 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.SVGScriptElement
-       (js_setType, setType, js_getType, getType, getTypeUnchecked,
-        SVGScriptElement, castToSVGScriptElement, gTypeSVGScriptElement)
+       (js_setType, setType, js_getType, getType, getTypeUnsafe,
+        getTypeUnchecked, SVGScriptElement(..), gTypeSVGScriptElement)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -19,6 +25,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"type\"] = $2;" js_setType ::
         SVGScriptElement -> Nullable JSString -> IO ()
@@ -37,6 +53,15 @@
         (MonadIO m, FromJSString result) =>
           SVGScriptElement -> m (Maybe result)
 getType self = liftIO (fromMaybeJSString <$> (js_getType (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGScriptElement.type Mozilla SVGScriptElement.type documentation> 
+getTypeUnsafe ::
+              (MonadIO m, HasCallStack, FromJSString result) =>
+                SVGScriptElement -> m result
+getTypeUnsafe self
+  = liftIO
+      ((fromMaybeJSString <$> (js_getType (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGScriptElement.type Mozilla SVGScriptElement.type documentation> 
 getTypeUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/SVGStopElement.hs b/src/GHCJS/DOM/JSFFI/Generated/SVGStopElement.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/SVGStopElement.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/SVGStopElement.hs
@@ -1,9 +1,15 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.SVGStopElement
-       (js_getOffset, getOffset, getOffsetUnchecked, SVGStopElement,
-        castToSVGStopElement, gTypeSVGStopElement)
+       (js_getOffset, getOffset, getOffsetUnsafe, getOffsetUnchecked,
+        SVGStopElement(..), gTypeSVGStopElement)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -19,6 +25,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"offset\"]" js_getOffset ::
         SVGStopElement -> IO (Nullable SVGAnimatedNumber)
@@ -27,6 +43,14 @@
 getOffset ::
           (MonadIO m) => SVGStopElement -> m (Maybe SVGAnimatedNumber)
 getOffset self = liftIO (nullableToMaybe <$> (js_getOffset (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGStopElement.offset Mozilla SVGStopElement.offset documentation> 
+getOffsetUnsafe ::
+                (MonadIO m, HasCallStack) => SVGStopElement -> m SVGAnimatedNumber
+getOffsetUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getOffset (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGStopElement.offset Mozilla SVGStopElement.offset documentation> 
 getOffsetUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/SVGStringList.hs b/src/GHCJS/DOM/JSFFI/Generated/SVGStringList.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/SVGStringList.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/SVGStringList.hs
@@ -1,14 +1,19 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.SVGStringList
        (js_clear, clear, js_initialize, initialize, initialize_,
         js_getItem, getItem, getItem_, js_insertItemBefore,
         insertItemBefore, insertItemBefore_, js_replaceItem, replaceItem,
         replaceItem_, js_removeItem, removeItem, removeItem_,
         js_appendItem, appendItem, appendItem_, js_getNumberOfItems,
-        getNumberOfItems, SVGStringList, castToSVGStringList,
-        gTypeSVGStringList)
+        getNumberOfItems, SVGStringList(..), gTypeSVGStringList)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -24,6 +29,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"clear\"]()" js_clear ::
         SVGStringList -> IO ()
diff --git a/src/GHCJS/DOM/JSFFI/Generated/SVGStyleElement.hs b/src/GHCJS/DOM/JSFFI/Generated/SVGStyleElement.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/SVGStyleElement.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/SVGStyleElement.hs
@@ -1,12 +1,17 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.SVGStyleElement
        (js_setDisabled, setDisabled, js_getDisabled, getDisabled,
         js_setType, setType, js_getType, getType, js_setMedia, setMedia,
         js_getMedia, getMedia, js_setTitle, setTitle, js_getTitle,
-        getTitle, SVGStyleElement, castToSVGStyleElement,
-        gTypeSVGStyleElement)
+        getTitle, SVGStyleElement(..), gTypeSVGStyleElement)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -22,6 +27,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"disabled\"] = $2;"
         js_setDisabled :: SVGStyleElement -> Bool -> IO ()
diff --git a/src/GHCJS/DOM/JSFFI/Generated/SVGTests.hs b/src/GHCJS/DOM/JSFFI/Generated/SVGTests.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/SVGTests.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/SVGTests.hs
@@ -1,14 +1,20 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.SVGTests
        (js_hasExtension, hasExtension, hasExtension_,
         js_getRequiredFeatures, getRequiredFeatures,
-        getRequiredFeaturesUnchecked, js_getRequiredExtensions,
-        getRequiredExtensions, getRequiredExtensionsUnchecked,
-        js_getSystemLanguage, getSystemLanguage,
-        getSystemLanguageUnchecked, SVGTests, castToSVGTests,
-        gTypeSVGTests)
+        getRequiredFeaturesUnsafe, getRequiredFeaturesUnchecked,
+        js_getRequiredExtensions, getRequiredExtensions,
+        getRequiredExtensionsUnsafe, getRequiredExtensionsUnchecked,
+        js_getSystemLanguage, getSystemLanguage, getSystemLanguageUnsafe,
+        getSystemLanguageUnchecked, SVGTests(..), gTypeSVGTests)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -24,6 +30,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe
         "($1[\"hasExtension\"]($2) ? 1 : 0)" js_hasExtension ::
@@ -52,6 +68,14 @@
   = liftIO (nullableToMaybe <$> (js_getRequiredFeatures (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGTests.requiredFeatures Mozilla SVGTests.requiredFeatures documentation> 
+getRequiredFeaturesUnsafe ::
+                          (MonadIO m, HasCallStack) => SVGTests -> m SVGStringList
+getRequiredFeaturesUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getRequiredFeatures (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGTests.requiredFeatures Mozilla SVGTests.requiredFeatures documentation> 
 getRequiredFeaturesUnchecked ::
                              (MonadIO m) => SVGTests -> m SVGStringList
 getRequiredFeaturesUnchecked self
@@ -68,6 +92,14 @@
   = liftIO (nullableToMaybe <$> (js_getRequiredExtensions (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGTests.requiredExtensions Mozilla SVGTests.requiredExtensions documentation> 
+getRequiredExtensionsUnsafe ::
+                            (MonadIO m, HasCallStack) => SVGTests -> m SVGStringList
+getRequiredExtensionsUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getRequiredExtensions (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGTests.requiredExtensions Mozilla SVGTests.requiredExtensions documentation> 
 getRequiredExtensionsUnchecked ::
                                (MonadIO m) => SVGTests -> m SVGStringList
 getRequiredExtensionsUnchecked self
@@ -82,6 +114,14 @@
                   (MonadIO m) => SVGTests -> m (Maybe SVGStringList)
 getSystemLanguage self
   = liftIO (nullableToMaybe <$> (js_getSystemLanguage (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGTests.systemLanguage Mozilla SVGTests.systemLanguage documentation> 
+getSystemLanguageUnsafe ::
+                        (MonadIO m, HasCallStack) => SVGTests -> m SVGStringList
+getSystemLanguageUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getSystemLanguage (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGTests.systemLanguage Mozilla SVGTests.systemLanguage documentation> 
 getSystemLanguageUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/SVGTextContentElement.hs b/src/GHCJS/DOM/JSFFI/Generated/SVGTextContentElement.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/SVGTextContentElement.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/SVGTextContentElement.hs
@@ -1,25 +1,33 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.SVGTextContentElement
        (js_getNumberOfChars, getNumberOfChars, getNumberOfChars_,
         js_getComputedTextLength, getComputedTextLength,
         getComputedTextLength_, js_getSubStringLength, getSubStringLength,
         getSubStringLength_, js_getStartPositionOfChar,
         getStartPositionOfChar, getStartPositionOfChar_,
-        getStartPositionOfCharUnchecked, js_getEndPositionOfChar,
-        getEndPositionOfChar, getEndPositionOfChar_,
+        getStartPositionOfCharUnsafe, getStartPositionOfCharUnchecked,
+        js_getEndPositionOfChar, getEndPositionOfChar,
+        getEndPositionOfChar_, getEndPositionOfCharUnsafe,
         getEndPositionOfCharUnchecked, js_getExtentOfChar, getExtentOfChar,
-        getExtentOfChar_, getExtentOfCharUnchecked, js_getRotationOfChar,
-        getRotationOfChar, getRotationOfChar_, js_getCharNumAtPosition,
-        getCharNumAtPosition, getCharNumAtPosition_, js_selectSubString,
-        selectSubString, pattern LENGTHADJUST_UNKNOWN,
-        pattern LENGTHADJUST_SPACING,
+        getExtentOfChar_, getExtentOfCharUnsafe, getExtentOfCharUnchecked,
+        js_getRotationOfChar, getRotationOfChar, getRotationOfChar_,
+        js_getCharNumAtPosition, getCharNumAtPosition,
+        getCharNumAtPosition_, js_selectSubString, selectSubString,
+        pattern LENGTHADJUST_UNKNOWN, pattern LENGTHADJUST_SPACING,
         pattern LENGTHADJUST_SPACINGANDGLYPHS, js_getTextLength,
-        getTextLength, getTextLengthUnchecked, js_getLengthAdjust,
-        getLengthAdjust, getLengthAdjustUnchecked, SVGTextContentElement,
-        castToSVGTextContentElement, gTypeSVGTextContentElement,
-        IsSVGTextContentElement, toSVGTextContentElement)
+        getTextLength, getTextLengthUnsafe, getTextLengthUnchecked,
+        js_getLengthAdjust, getLengthAdjust, getLengthAdjustUnsafe,
+        getLengthAdjustUnchecked, SVGTextContentElement(..),
+        gTypeSVGTextContentElement, IsSVGTextContentElement,
+        toSVGTextContentElement)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -35,6 +43,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"getNumberOfChars\"]()"
         js_getNumberOfChars :: SVGTextContentElement -> IO Int
@@ -113,6 +131,16 @@
          (js_getStartPositionOfChar (toSVGTextContentElement self) offset))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGTextContentElement.getStartPositionOfChar Mozilla SVGTextContentElement.getStartPositionOfChar documentation> 
+getStartPositionOfCharUnsafe ::
+                             (MonadIO m, IsSVGTextContentElement self, HasCallStack) =>
+                               self -> Word -> m SVGPoint
+getStartPositionOfCharUnsafe self offset
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_getStartPositionOfChar (toSVGTextContentElement self) offset))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGTextContentElement.getStartPositionOfChar Mozilla SVGTextContentElement.getStartPositionOfChar documentation> 
 getStartPositionOfCharUnchecked ::
                                 (MonadIO m, IsSVGTextContentElement self) =>
                                   self -> Word -> m SVGPoint
@@ -143,6 +171,16 @@
          (js_getEndPositionOfChar (toSVGTextContentElement self) offset))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGTextContentElement.getEndPositionOfChar Mozilla SVGTextContentElement.getEndPositionOfChar documentation> 
+getEndPositionOfCharUnsafe ::
+                           (MonadIO m, IsSVGTextContentElement self, HasCallStack) =>
+                             self -> Word -> m SVGPoint
+getEndPositionOfCharUnsafe self offset
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_getEndPositionOfChar (toSVGTextContentElement self) offset))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGTextContentElement.getEndPositionOfChar Mozilla SVGTextContentElement.getEndPositionOfChar documentation> 
 getEndPositionOfCharUnchecked ::
                               (MonadIO m, IsSVGTextContentElement self) =>
                                 self -> Word -> m SVGPoint
@@ -172,6 +210,16 @@
       (void (js_getExtentOfChar (toSVGTextContentElement self) offset))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGTextContentElement.getExtentOfChar Mozilla SVGTextContentElement.getExtentOfChar documentation> 
+getExtentOfCharUnsafe ::
+                      (MonadIO m, IsSVGTextContentElement self, HasCallStack) =>
+                        self -> Word -> m SVGRect
+getExtentOfCharUnsafe self offset
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_getExtentOfChar (toSVGTextContentElement self) offset))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGTextContentElement.getExtentOfChar Mozilla SVGTextContentElement.getExtentOfChar documentation> 
 getExtentOfCharUnchecked ::
                          (MonadIO m, IsSVGTextContentElement self) =>
                            self -> Word -> m SVGRect
@@ -250,6 +298,16 @@
          (js_getTextLength (toSVGTextContentElement self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGTextContentElement.textLength Mozilla SVGTextContentElement.textLength documentation> 
+getTextLengthUnsafe ::
+                    (MonadIO m, IsSVGTextContentElement self, HasCallStack) =>
+                      self -> m SVGAnimatedLength
+getTextLengthUnsafe self
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_getTextLength (toSVGTextContentElement self)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGTextContentElement.textLength Mozilla SVGTextContentElement.textLength documentation> 
 getTextLengthUnchecked ::
                        (MonadIO m, IsSVGTextContentElement self) =>
                          self -> m SVGAnimatedLength
@@ -270,6 +328,16 @@
   = liftIO
       (nullableToMaybe <$>
          (js_getLengthAdjust (toSVGTextContentElement self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGTextContentElement.lengthAdjust Mozilla SVGTextContentElement.lengthAdjust documentation> 
+getLengthAdjustUnsafe ::
+                      (MonadIO m, IsSVGTextContentElement self, HasCallStack) =>
+                        self -> m SVGAnimatedEnumeration
+getLengthAdjustUnsafe self
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_getLengthAdjust (toSVGTextContentElement self)))
+         >>= maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGTextContentElement.lengthAdjust Mozilla SVGTextContentElement.lengthAdjust documentation> 
 getLengthAdjustUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/SVGTextPathElement.hs b/src/GHCJS/DOM/JSFFI/Generated/SVGTextPathElement.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/SVGTextPathElement.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/SVGTextPathElement.hs
@@ -1,4 +1,9 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.SVGTextPathElement
        (pattern TEXTPATH_METHODTYPE_UNKNOWN,
         pattern TEXTPATH_METHODTYPE_ALIGN,
@@ -6,12 +11,13 @@
         pattern TEXTPATH_SPACINGTYPE_UNKNOWN,
         pattern TEXTPATH_SPACINGTYPE_AUTO,
         pattern TEXTPATH_SPACINGTYPE_EXACT, js_getStartOffset,
-        getStartOffset, getStartOffsetUnchecked, js_getMethod, getMethod,
-        getMethodUnchecked, js_getSpacing, getSpacing, getSpacingUnchecked,
-        SVGTextPathElement, castToSVGTextPathElement,
-        gTypeSVGTextPathElement)
+        getStartOffset, getStartOffsetUnsafe, getStartOffsetUnchecked,
+        js_getMethod, getMethod, getMethodUnsafe, getMethodUnchecked,
+        js_getSpacing, getSpacing, getSpacingUnsafe, getSpacingUnchecked,
+        SVGTextPathElement(..), gTypeSVGTextPathElement)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -27,6 +33,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
 pattern TEXTPATH_METHODTYPE_UNKNOWN = 0
 pattern TEXTPATH_METHODTYPE_ALIGN = 1
 pattern TEXTPATH_METHODTYPE_STRETCH = 2
@@ -45,6 +61,15 @@
   = liftIO (nullableToMaybe <$> (js_getStartOffset (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGTextPathElement.startOffset Mozilla SVGTextPathElement.startOffset documentation> 
+getStartOffsetUnsafe ::
+                     (MonadIO m, HasCallStack) =>
+                       SVGTextPathElement -> m SVGAnimatedLength
+getStartOffsetUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getStartOffset (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGTextPathElement.startOffset Mozilla SVGTextPathElement.startOffset documentation> 
 getStartOffsetUnchecked ::
                         (MonadIO m) => SVGTextPathElement -> m SVGAnimatedLength
 getStartOffsetUnchecked self
@@ -61,6 +86,15 @@
 getMethod self = liftIO (nullableToMaybe <$> (js_getMethod (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGTextPathElement.method Mozilla SVGTextPathElement.method documentation> 
+getMethodUnsafe ::
+                (MonadIO m, HasCallStack) =>
+                  SVGTextPathElement -> m SVGAnimatedEnumeration
+getMethodUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getMethod (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGTextPathElement.method Mozilla SVGTextPathElement.method documentation> 
 getMethodUnchecked ::
                    (MonadIO m) => SVGTextPathElement -> m SVGAnimatedEnumeration
 getMethodUnchecked self
@@ -75,6 +109,15 @@
              SVGTextPathElement -> m (Maybe SVGAnimatedEnumeration)
 getSpacing self
   = liftIO (nullableToMaybe <$> (js_getSpacing (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGTextPathElement.spacing Mozilla SVGTextPathElement.spacing documentation> 
+getSpacingUnsafe ::
+                 (MonadIO m, HasCallStack) =>
+                   SVGTextPathElement -> m SVGAnimatedEnumeration
+getSpacingUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getSpacing (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGTextPathElement.spacing Mozilla SVGTextPathElement.spacing documentation> 
 getSpacingUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/SVGTextPositioningElement.hs b/src/GHCJS/DOM/JSFFI/Generated/SVGTextPositioningElement.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/SVGTextPositioningElement.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/SVGTextPositioningElement.hs
@@ -1,13 +1,19 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.SVGTextPositioningElement
-       (js_getX, getX, getXUnchecked, js_getY, getY, getYUnchecked,
-        js_getDx, getDx, getDxUnchecked, js_getDy, getDy, getDyUnchecked,
-        js_getRotate, getRotate, getRotateUnchecked,
-        SVGTextPositioningElement, castToSVGTextPositioningElement,
-        gTypeSVGTextPositioningElement, IsSVGTextPositioningElement,
-        toSVGTextPositioningElement)
+       (js_getX, getX, getXUnsafe, getXUnchecked, js_getY, getY,
+        getYUnsafe, getYUnchecked, js_getDx, getDx, getDxUnsafe,
+        getDxUnchecked, js_getDy, getDy, getDyUnsafe, getDyUnchecked,
+        js_getRotate, getRotate, getRotateUnsafe, getRotateUnchecked,
+        SVGTextPositioningElement(..), gTypeSVGTextPositioningElement,
+        IsSVGTextPositioningElement, toSVGTextPositioningElement)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -23,6 +29,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"x\"]" js_getX ::
         SVGTextPositioningElement -> IO (Nullable SVGAnimatedLengthList)
@@ -36,6 +52,15 @@
       (nullableToMaybe <$> (js_getX (toSVGTextPositioningElement self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGTextPositioningElement.x Mozilla SVGTextPositioningElement.x documentation> 
+getXUnsafe ::
+           (MonadIO m, IsSVGTextPositioningElement self, HasCallStack) =>
+             self -> m SVGAnimatedLengthList
+getXUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getX (toSVGTextPositioningElement self)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGTextPositioningElement.x Mozilla SVGTextPositioningElement.x documentation> 
 getXUnchecked ::
               (MonadIO m, IsSVGTextPositioningElement self) =>
                 self -> m SVGAnimatedLengthList
@@ -56,6 +81,15 @@
       (nullableToMaybe <$> (js_getY (toSVGTextPositioningElement self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGTextPositioningElement.y Mozilla SVGTextPositioningElement.y documentation> 
+getYUnsafe ::
+           (MonadIO m, IsSVGTextPositioningElement self, HasCallStack) =>
+             self -> m SVGAnimatedLengthList
+getYUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getY (toSVGTextPositioningElement self)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGTextPositioningElement.y Mozilla SVGTextPositioningElement.y documentation> 
 getYUnchecked ::
               (MonadIO m, IsSVGTextPositioningElement self) =>
                 self -> m SVGAnimatedLengthList
@@ -76,6 +110,16 @@
       (nullableToMaybe <$> (js_getDx (toSVGTextPositioningElement self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGTextPositioningElement.dx Mozilla SVGTextPositioningElement.dx documentation> 
+getDxUnsafe ::
+            (MonadIO m, IsSVGTextPositioningElement self, HasCallStack) =>
+              self -> m SVGAnimatedLengthList
+getDxUnsafe self
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_getDx (toSVGTextPositioningElement self)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGTextPositioningElement.dx Mozilla SVGTextPositioningElement.dx documentation> 
 getDxUnchecked ::
                (MonadIO m, IsSVGTextPositioningElement self) =>
                  self -> m SVGAnimatedLengthList
@@ -96,6 +140,16 @@
       (nullableToMaybe <$> (js_getDy (toSVGTextPositioningElement self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGTextPositioningElement.dy Mozilla SVGTextPositioningElement.dy documentation> 
+getDyUnsafe ::
+            (MonadIO m, IsSVGTextPositioningElement self, HasCallStack) =>
+              self -> m SVGAnimatedLengthList
+getDyUnsafe self
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_getDy (toSVGTextPositioningElement self)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGTextPositioningElement.dy Mozilla SVGTextPositioningElement.dy documentation> 
 getDyUnchecked ::
                (MonadIO m, IsSVGTextPositioningElement self) =>
                  self -> m SVGAnimatedLengthList
@@ -115,6 +169,16 @@
   = liftIO
       (nullableToMaybe <$>
          (js_getRotate (toSVGTextPositioningElement self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGTextPositioningElement.rotate Mozilla SVGTextPositioningElement.rotate documentation> 
+getRotateUnsafe ::
+                (MonadIO m, IsSVGTextPositioningElement self, HasCallStack) =>
+                  self -> m SVGAnimatedNumberList
+getRotateUnsafe self
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_getRotate (toSVGTextPositioningElement self)))
+         >>= maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGTextPositioningElement.rotate Mozilla SVGTextPositioningElement.rotate documentation> 
 getRotateUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/SVGTransform.hs b/src/GHCJS/DOM/JSFFI/Generated/SVGTransform.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/SVGTransform.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/SVGTransform.hs
@@ -1,4 +1,9 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.SVGTransform
        (js_setMatrix, setMatrix, js_setTranslate, setTranslate,
         js_setScale, setScale, js_setRotate, setRotate, js_setSkewX,
@@ -6,11 +11,12 @@
         pattern SVG_TRANSFORM_MATRIX, pattern SVG_TRANSFORM_TRANSLATE,
         pattern SVG_TRANSFORM_SCALE, pattern SVG_TRANSFORM_ROTATE,
         pattern SVG_TRANSFORM_SKEWX, pattern SVG_TRANSFORM_SKEWY,
-        js_getType, getType, js_getMatrix, getMatrix, getMatrixUnchecked,
-        js_getAngle, getAngle, SVGTransform, castToSVGTransform,
+        js_getType, getType, js_getMatrix, getMatrix, getMatrixUnsafe,
+        getMatrixUnchecked, js_getAngle, getAngle, SVGTransform(..),
         gTypeSVGTransform)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -26,6 +32,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"setMatrix\"]($2)"
         js_setMatrix :: SVGTransform -> Nullable SVGMatrix -> IO ()
@@ -93,6 +109,14 @@
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGTransform.matrix Mozilla SVGTransform.matrix documentation> 
 getMatrix :: (MonadIO m) => SVGTransform -> m (Maybe SVGMatrix)
 getMatrix self = liftIO (nullableToMaybe <$> (js_getMatrix (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGTransform.matrix Mozilla SVGTransform.matrix documentation> 
+getMatrixUnsafe ::
+                (MonadIO m, HasCallStack) => SVGTransform -> m SVGMatrix
+getMatrixUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getMatrix (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGTransform.matrix Mozilla SVGTransform.matrix documentation> 
 getMatrixUnchecked :: (MonadIO m) => SVGTransform -> m SVGMatrix
diff --git a/src/GHCJS/DOM/JSFFI/Generated/SVGTransformList.hs b/src/GHCJS/DOM/JSFFI/Generated/SVGTransformList.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/SVGTransformList.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/SVGTransformList.hs
@@ -1,20 +1,28 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.SVGTransformList
        (js_clear, clear, js_initialize, initialize, initialize_,
-        initializeUnchecked, js_getItem, getItem, getItem_,
-        getItemUnchecked, js_insertItemBefore, insertItemBefore,
-        insertItemBefore_, insertItemBeforeUnchecked, js_replaceItem,
-        replaceItem, replaceItem_, replaceItemUnchecked, js_removeItem,
-        removeItem, removeItem_, removeItemUnchecked, js_appendItem,
-        appendItem, appendItem_, appendItemUnchecked,
+        initializeUnsafe, initializeUnchecked, js_getItem, getItem,
+        getItem_, getItemUnsafe, getItemUnchecked, js_insertItemBefore,
+        insertItemBefore, insertItemBefore_, insertItemBeforeUnsafe,
+        insertItemBeforeUnchecked, js_replaceItem, replaceItem,
+        replaceItem_, replaceItemUnsafe, replaceItemUnchecked,
+        js_removeItem, removeItem, removeItem_, removeItemUnsafe,
+        removeItemUnchecked, js_appendItem, appendItem, appendItem_,
+        appendItemUnsafe, appendItemUnchecked,
         js_createSVGTransformFromMatrix, createSVGTransformFromMatrix,
-        createSVGTransformFromMatrix_,
+        createSVGTransformFromMatrix_, createSVGTransformFromMatrixUnsafe,
         createSVGTransformFromMatrixUnchecked, js_consolidate, consolidate,
-        consolidate_, consolidateUnchecked, js_getNumberOfItems,
-        getNumberOfItems, SVGTransformList, castToSVGTransformList,
+        consolidate_, consolidateUnsafe, consolidateUnchecked,
+        js_getNumberOfItems, getNumberOfItems, SVGTransformList(..),
         gTypeSVGTransformList)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -30,6 +38,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"clear\"]()" js_clear ::
         SVGTransformList -> IO ()
@@ -58,6 +76,16 @@
   = liftIO (void (js_initialize (self) (maybeToNullable item)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGTransformList.initialize Mozilla SVGTransformList.initialize documentation> 
+initializeUnsafe ::
+                 (MonadIO m, HasCallStack) =>
+                   SVGTransformList -> Maybe SVGTransform -> m SVGTransform
+initializeUnsafe self item
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_initialize (self) (maybeToNullable item)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGTransformList.initialize Mozilla SVGTransformList.initialize documentation> 
 initializeUnchecked ::
                     (MonadIO m) =>
                       SVGTransformList -> Maybe SVGTransform -> m SVGTransform
@@ -80,6 +108,15 @@
 getItem_ self index = liftIO (void (js_getItem (self) index))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGTransformList.getItem Mozilla SVGTransformList.getItem documentation> 
+getItemUnsafe ::
+              (MonadIO m, HasCallStack) =>
+                SVGTransformList -> Word -> m SVGTransform
+getItemUnsafe self index
+  = liftIO
+      ((nullableToMaybe <$> (js_getItem (self) index)) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGTransformList.getItem Mozilla SVGTransformList.getItem documentation> 
 getItemUnchecked ::
                  (MonadIO m) => SVGTransformList -> Word -> m SVGTransform
 getItemUnchecked self index
@@ -109,6 +146,16 @@
       (void (js_insertItemBefore (self) (maybeToNullable item) index))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGTransformList.insertItemBefore Mozilla SVGTransformList.insertItemBefore documentation> 
+insertItemBeforeUnsafe ::
+                       (MonadIO m, HasCallStack) =>
+                         SVGTransformList -> Maybe SVGTransform -> Word -> m SVGTransform
+insertItemBeforeUnsafe self item index
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_insertItemBefore (self) (maybeToNullable item) index))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGTransformList.insertItemBefore Mozilla SVGTransformList.insertItemBefore documentation> 
 insertItemBeforeUnchecked ::
                           (MonadIO m) =>
                             SVGTransformList -> Maybe SVGTransform -> Word -> m SVGTransform
@@ -141,6 +188,16 @@
       (void (js_replaceItem (self) (maybeToNullable item) index))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGTransformList.replaceItem Mozilla SVGTransformList.replaceItem documentation> 
+replaceItemUnsafe ::
+                  (MonadIO m, HasCallStack) =>
+                    SVGTransformList -> Maybe SVGTransform -> Word -> m SVGTransform
+replaceItemUnsafe self item index
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_replaceItem (self) (maybeToNullable item) index))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGTransformList.replaceItem Mozilla SVGTransformList.replaceItem documentation> 
 replaceItemUnchecked ::
                      (MonadIO m) =>
                        SVGTransformList -> Maybe SVGTransform -> Word -> m SVGTransform
@@ -164,6 +221,15 @@
 removeItem_ self index = liftIO (void (js_removeItem (self) index))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGTransformList.removeItem Mozilla SVGTransformList.removeItem documentation> 
+removeItemUnsafe ::
+                 (MonadIO m, HasCallStack) =>
+                   SVGTransformList -> Word -> m SVGTransform
+removeItemUnsafe self index
+  = liftIO
+      ((nullableToMaybe <$> (js_removeItem (self) index)) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGTransformList.removeItem Mozilla SVGTransformList.removeItem documentation> 
 removeItemUnchecked ::
                     (MonadIO m) => SVGTransformList -> Word -> m SVGTransform
 removeItemUnchecked self index
@@ -190,6 +256,16 @@
   = liftIO (void (js_appendItem (self) (maybeToNullable item)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGTransformList.appendItem Mozilla SVGTransformList.appendItem documentation> 
+appendItemUnsafe ::
+                 (MonadIO m, HasCallStack) =>
+                   SVGTransformList -> Maybe SVGTransform -> m SVGTransform
+appendItemUnsafe self item
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_appendItem (self) (maybeToNullable item)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGTransformList.appendItem Mozilla SVGTransformList.appendItem documentation> 
 appendItemUnchecked ::
                     (MonadIO m) =>
                       SVGTransformList -> Maybe SVGTransform -> m SVGTransform
@@ -222,6 +298,16 @@
          (js_createSVGTransformFromMatrix (self) (maybeToNullable matrix)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGTransformList.createSVGTransformFromMatrix Mozilla SVGTransformList.createSVGTransformFromMatrix documentation> 
+createSVGTransformFromMatrixUnsafe ::
+                                   (MonadIO m, HasCallStack) =>
+                                     SVGTransformList -> Maybe SVGMatrix -> m SVGTransform
+createSVGTransformFromMatrixUnsafe self matrix
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_createSVGTransformFromMatrix (self) (maybeToNullable matrix)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGTransformList.createSVGTransformFromMatrix Mozilla SVGTransformList.createSVGTransformFromMatrix documentation> 
 createSVGTransformFromMatrixUnchecked ::
                                       (MonadIO m) =>
                                         SVGTransformList -> Maybe SVGMatrix -> m SVGTransform
@@ -242,6 +328,14 @@
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGTransformList.consolidate Mozilla SVGTransformList.consolidate documentation> 
 consolidate_ :: (MonadIO m) => SVGTransformList -> m ()
 consolidate_ self = liftIO (void (js_consolidate (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGTransformList.consolidate Mozilla SVGTransformList.consolidate documentation> 
+consolidateUnsafe ::
+                  (MonadIO m, HasCallStack) => SVGTransformList -> m SVGTransform
+consolidateUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_consolidate (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGTransformList.consolidate Mozilla SVGTransformList.consolidate documentation> 
 consolidateUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/SVGURIReference.hs b/src/GHCJS/DOM/JSFFI/Generated/SVGURIReference.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/SVGURIReference.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/SVGURIReference.hs
@@ -1,9 +1,15 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.SVGURIReference
-       (js_getHref, getHref, getHrefUnchecked, SVGURIReference,
-        castToSVGURIReference, gTypeSVGURIReference)
+       (js_getHref, getHref, getHrefUnsafe, getHrefUnchecked,
+        SVGURIReference(..), gTypeSVGURIReference)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -19,6 +25,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"href\"]" js_getHref ::
         SVGURIReference -> IO (Nullable SVGAnimatedString)
@@ -27,6 +43,14 @@
 getHref ::
         (MonadIO m) => SVGURIReference -> m (Maybe SVGAnimatedString)
 getHref self = liftIO (nullableToMaybe <$> (js_getHref (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGURIReference.href Mozilla SVGURIReference.href documentation> 
+getHrefUnsafe ::
+              (MonadIO m, HasCallStack) => SVGURIReference -> m SVGAnimatedString
+getHrefUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getHref (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGURIReference.href Mozilla SVGURIReference.href documentation> 
 getHrefUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/SVGUnitTypes.hs b/src/GHCJS/DOM/JSFFI/Generated/SVGUnitTypes.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/SVGUnitTypes.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/SVGUnitTypes.hs
@@ -1,11 +1,17 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.SVGUnitTypes
        (pattern SVG_UNIT_TYPE_UNKNOWN,
         pattern SVG_UNIT_TYPE_USERSPACEONUSE,
-        pattern SVG_UNIT_TYPE_OBJECTBOUNDINGBOX, SVGUnitTypes,
-        castToSVGUnitTypes, gTypeSVGUnitTypes)
+        pattern SVG_UNIT_TYPE_OBJECTBOUNDINGBOX, SVGUnitTypes(..),
+        gTypeSVGUnitTypes)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -21,6 +27,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
 pattern SVG_UNIT_TYPE_UNKNOWN = 0
 pattern SVG_UNIT_TYPE_USERSPACEONUSE = 1
 pattern SVG_UNIT_TYPE_OBJECTBOUNDINGBOX = 2
diff --git a/src/GHCJS/DOM/JSFFI/Generated/SVGUseElement.hs b/src/GHCJS/DOM/JSFFI/Generated/SVGUseElement.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/SVGUseElement.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/SVGUseElement.hs
@@ -1,11 +1,17 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.SVGUseElement
-       (js_getX, getX, getXUnchecked, js_getY, getY, getYUnchecked,
-        js_getWidth, getWidth, getWidthUnchecked, js_getHeight, getHeight,
-        getHeightUnchecked, SVGUseElement, castToSVGUseElement,
-        gTypeSVGUseElement)
+       (js_getX, getX, getXUnsafe, getXUnchecked, js_getY, getY,
+        getYUnsafe, getYUnchecked, js_getWidth, getWidth, getWidthUnsafe,
+        getWidthUnchecked, js_getHeight, getHeight, getHeightUnsafe,
+        getHeightUnchecked, SVGUseElement(..), gTypeSVGUseElement)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -21,6 +27,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"x\"]" js_getX ::
         SVGUseElement -> IO (Nullable SVGAnimatedLength)
@@ -30,6 +46,14 @@
 getX self = liftIO (nullableToMaybe <$> (js_getX (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGUseElement.x Mozilla SVGUseElement.x documentation> 
+getXUnsafe ::
+           (MonadIO m, HasCallStack) => SVGUseElement -> m SVGAnimatedLength
+getXUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getX (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGUseElement.x Mozilla SVGUseElement.x documentation> 
 getXUnchecked ::
               (MonadIO m) => SVGUseElement -> m SVGAnimatedLength
 getXUnchecked self
@@ -43,6 +67,14 @@
 getY self = liftIO (nullableToMaybe <$> (js_getY (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGUseElement.y Mozilla SVGUseElement.y documentation> 
+getYUnsafe ::
+           (MonadIO m, HasCallStack) => SVGUseElement -> m SVGAnimatedLength
+getYUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getY (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGUseElement.y Mozilla SVGUseElement.y documentation> 
 getYUnchecked ::
               (MonadIO m) => SVGUseElement -> m SVGAnimatedLength
 getYUnchecked self
@@ -57,6 +89,14 @@
 getWidth self = liftIO (nullableToMaybe <$> (js_getWidth (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGUseElement.width Mozilla SVGUseElement.width documentation> 
+getWidthUnsafe ::
+               (MonadIO m, HasCallStack) => SVGUseElement -> m SVGAnimatedLength
+getWidthUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getWidth (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGUseElement.width Mozilla SVGUseElement.width documentation> 
 getWidthUnchecked ::
                   (MonadIO m) => SVGUseElement -> m SVGAnimatedLength
 getWidthUnchecked self
@@ -69,6 +109,14 @@
 getHeight ::
           (MonadIO m) => SVGUseElement -> m (Maybe SVGAnimatedLength)
 getHeight self = liftIO (nullableToMaybe <$> (js_getHeight (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGUseElement.height Mozilla SVGUseElement.height documentation> 
+getHeightUnsafe ::
+                (MonadIO m, HasCallStack) => SVGUseElement -> m SVGAnimatedLength
+getHeightUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getHeight (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGUseElement.height Mozilla SVGUseElement.height documentation> 
 getHeightUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/SVGViewElement.hs b/src/GHCJS/DOM/JSFFI/Generated/SVGViewElement.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/SVGViewElement.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/SVGViewElement.hs
@@ -1,9 +1,15 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.SVGViewElement
-       (js_getViewTarget, getViewTarget, getViewTargetUnchecked,
-        SVGViewElement, castToSVGViewElement, gTypeSVGViewElement)
+       (js_getViewTarget, getViewTarget, getViewTargetUnsafe,
+        getViewTargetUnchecked, SVGViewElement(..), gTypeSVGViewElement)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -19,6 +25,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"viewTarget\"]"
         js_getViewTarget :: SVGViewElement -> IO (Nullable SVGStringList)
@@ -28,6 +44,14 @@
               (MonadIO m) => SVGViewElement -> m (Maybe SVGStringList)
 getViewTarget self
   = liftIO (nullableToMaybe <$> (js_getViewTarget (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGViewElement.viewTarget Mozilla SVGViewElement.viewTarget documentation> 
+getViewTargetUnsafe ::
+                    (MonadIO m, HasCallStack) => SVGViewElement -> m SVGStringList
+getViewTargetUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getViewTarget (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGViewElement.viewTarget Mozilla SVGViewElement.viewTarget documentation> 
 getViewTargetUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/SVGViewSpec.hs b/src/GHCJS/DOM/JSFFI/Generated/SVGViewSpec.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/SVGViewSpec.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/SVGViewSpec.hs
@@ -1,15 +1,21 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.SVGViewSpec
-       (js_getTransform, getTransform, getTransformUnchecked,
-        js_getViewTarget, getViewTarget, getViewTargetUnchecked,
-        js_getViewBoxString, getViewBoxString,
-        js_getPreserveAspectRatioString, getPreserveAspectRatioString,
-        js_getTransformString, getTransformString, js_getViewTargetString,
-        getViewTargetString, js_setZoomAndPan, setZoomAndPan,
-        js_getZoomAndPan, getZoomAndPan, SVGViewSpec, castToSVGViewSpec,
-        gTypeSVGViewSpec)
+       (js_getTransform, getTransform, getTransformUnsafe,
+        getTransformUnchecked, js_getViewTarget, getViewTarget,
+        getViewTargetUnsafe, getViewTargetUnchecked, js_getViewBoxString,
+        getViewBoxString, js_getPreserveAspectRatioString,
+        getPreserveAspectRatioString, js_getTransformString,
+        getTransformString, js_getViewTargetString, getViewTargetString,
+        js_setZoomAndPan, setZoomAndPan, js_getZoomAndPan, getZoomAndPan,
+        SVGViewSpec(..), gTypeSVGViewSpec)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -25,6 +31,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"transform\"]"
         js_getTransform :: SVGViewSpec -> IO (Nullable SVGTransformList)
@@ -36,6 +52,14 @@
   = liftIO (nullableToMaybe <$> (js_getTransform (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGViewSpec.transform Mozilla SVGViewSpec.transform documentation> 
+getTransformUnsafe ::
+                   (MonadIO m, HasCallStack) => SVGViewSpec -> m SVGTransformList
+getTransformUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getTransform (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGViewSpec.transform Mozilla SVGViewSpec.transform documentation> 
 getTransformUnchecked ::
                       (MonadIO m) => SVGViewSpec -> m SVGTransformList
 getTransformUnchecked self
@@ -48,6 +72,14 @@
 getViewTarget :: (MonadIO m) => SVGViewSpec -> m (Maybe SVGElement)
 getViewTarget self
   = liftIO (nullableToMaybe <$> (js_getViewTarget (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGViewSpec.viewTarget Mozilla SVGViewSpec.viewTarget documentation> 
+getViewTargetUnsafe ::
+                    (MonadIO m, HasCallStack) => SVGViewSpec -> m SVGElement
+getViewTargetUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getViewTarget (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGViewSpec.viewTarget Mozilla SVGViewSpec.viewTarget documentation> 
 getViewTargetUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/SVGZoomAndPan.hs b/src/GHCJS/DOM/JSFFI/Generated/SVGZoomAndPan.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/SVGZoomAndPan.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/SVGZoomAndPan.hs
@@ -1,11 +1,17 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.SVGZoomAndPan
        (pattern SVG_ZOOMANDPAN_UNKNOWN, pattern SVG_ZOOMANDPAN_DISABLE,
         pattern SVG_ZOOMANDPAN_MAGNIFY, js_setZoomAndPan, setZoomAndPan,
-        js_getZoomAndPan, getZoomAndPan, SVGZoomAndPan,
-        castToSVGZoomAndPan, gTypeSVGZoomAndPan)
+        js_getZoomAndPan, getZoomAndPan, SVGZoomAndPan(..),
+        gTypeSVGZoomAndPan)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -21,6 +27,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
 pattern SVG_ZOOMANDPAN_UNKNOWN = 0
 pattern SVG_ZOOMANDPAN_DISABLE = 1
 pattern SVG_ZOOMANDPAN_MAGNIFY = 2
diff --git a/src/GHCJS/DOM/JSFFI/Generated/SVGZoomEvent.hs b/src/GHCJS/DOM/JSFFI/Generated/SVGZoomEvent.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/SVGZoomEvent.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/SVGZoomEvent.hs
@@ -1,13 +1,20 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.SVGZoomEvent
-       (js_getZoomRectScreen, getZoomRectScreen,
+       (js_getZoomRectScreen, getZoomRectScreen, getZoomRectScreenUnsafe,
         getZoomRectScreenUnchecked, js_getPreviousScale, getPreviousScale,
         js_getPreviousTranslate, getPreviousTranslate,
-        getPreviousTranslateUnchecked, js_getNewScale, getNewScale,
-        js_getNewTranslate, getNewTranslate, getNewTranslateUnchecked,
-        SVGZoomEvent, castToSVGZoomEvent, gTypeSVGZoomEvent)
+        getPreviousTranslateUnsafe, getPreviousTranslateUnchecked,
+        js_getNewScale, getNewScale, js_getNewTranslate, getNewTranslate,
+        getNewTranslateUnsafe, getNewTranslateUnchecked, SVGZoomEvent(..),
+        gTypeSVGZoomEvent)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -23,6 +30,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"zoomRectScreen\"]"
         js_getZoomRectScreen :: SVGZoomEvent -> IO (Nullable SVGRect)
@@ -34,6 +51,14 @@
   = liftIO (nullableToMaybe <$> (js_getZoomRectScreen (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGZoomEvent.zoomRectScreen Mozilla SVGZoomEvent.zoomRectScreen documentation> 
+getZoomRectScreenUnsafe ::
+                        (MonadIO m, HasCallStack) => SVGZoomEvent -> m SVGRect
+getZoomRectScreenUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getZoomRectScreen (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGZoomEvent.zoomRectScreen Mozilla SVGZoomEvent.zoomRectScreen documentation> 
 getZoomRectScreenUnchecked ::
                            (MonadIO m) => SVGZoomEvent -> m SVGRect
 getZoomRectScreenUnchecked self
@@ -57,6 +82,14 @@
   = liftIO (nullableToMaybe <$> (js_getPreviousTranslate (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGZoomEvent.previousTranslate Mozilla SVGZoomEvent.previousTranslate documentation> 
+getPreviousTranslateUnsafe ::
+                           (MonadIO m, HasCallStack) => SVGZoomEvent -> m SVGPoint
+getPreviousTranslateUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getPreviousTranslate (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGZoomEvent.previousTranslate Mozilla SVGZoomEvent.previousTranslate documentation> 
 getPreviousTranslateUnchecked ::
                               (MonadIO m) => SVGZoomEvent -> m SVGPoint
 getPreviousTranslateUnchecked self
@@ -78,6 +111,14 @@
                 (MonadIO m) => SVGZoomEvent -> m (Maybe SVGPoint)
 getNewTranslate self
   = liftIO (nullableToMaybe <$> (js_getNewTranslate (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGZoomEvent.newTranslate Mozilla SVGZoomEvent.newTranslate documentation> 
+getNewTranslateUnsafe ::
+                      (MonadIO m, HasCallStack) => SVGZoomEvent -> m SVGPoint
+getNewTranslateUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getNewTranslate (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGZoomEvent.newTranslate Mozilla SVGZoomEvent.newTranslate documentation> 
 getNewTranslateUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/Screen.hs b/src/GHCJS/DOM/JSFFI/Generated/Screen.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/Screen.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/Screen.hs
@@ -1,12 +1,18 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.Screen
        (js_getHeight, getHeight, js_getWidth, getWidth, js_getColorDepth,
         getColorDepth, js_getPixelDepth, getPixelDepth, js_getAvailLeft,
         getAvailLeft, js_getAvailTop, getAvailTop, js_getAvailHeight,
-        getAvailHeight, js_getAvailWidth, getAvailWidth, Screen,
-        castToScreen, gTypeScreen)
+        getAvailHeight, js_getAvailWidth, getAvailWidth, Screen(..),
+        gTypeScreen)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -22,6 +28,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"height\"]" js_getHeight ::
         Screen -> IO Word
diff --git a/src/GHCJS/DOM/JSFFI/Generated/ScriptProcessorNode.hs b/src/GHCJS/DOM/JSFFI/Generated/ScriptProcessorNode.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/ScriptProcessorNode.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/ScriptProcessorNode.hs
@@ -1,10 +1,15 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.ScriptProcessorNode
        (audioProcess, js_getBufferSize, getBufferSize,
-        ScriptProcessorNode, castToScriptProcessorNode,
-        gTypeScriptProcessorNode)
+        ScriptProcessorNode(..), gTypeScriptProcessorNode)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -20,6 +25,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/ScriptProcessorNode.onaudioprocess Mozilla ScriptProcessorNode.onaudioprocess documentation> 
 audioProcess :: EventName ScriptProcessorNode AudioProcessingEvent
diff --git a/src/GHCJS/DOM/JSFFI/Generated/ScriptProfile.hs b/src/GHCJS/DOM/JSFFI/Generated/ScriptProfile.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/ScriptProfile.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/ScriptProfile.hs
@@ -1,10 +1,16 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.ScriptProfile
        (js_getTitle, getTitle, js_getUid, getUid, js_getRootNode,
-        getRootNode, getRootNodeUnchecked, ScriptProfile,
-        castToScriptProfile, gTypeScriptProfile)
+        getRootNode, getRootNodeUnsafe, getRootNodeUnchecked,
+        ScriptProfile(..), gTypeScriptProfile)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -20,6 +26,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"title\"]" js_getTitle ::
         ScriptProfile -> IO JSString
@@ -44,6 +60,14 @@
             (MonadIO m) => ScriptProfile -> m (Maybe ScriptProfileNode)
 getRootNode self
   = liftIO (nullableToMaybe <$> (js_getRootNode (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/ScriptProfile.rootNode Mozilla ScriptProfile.rootNode documentation> 
+getRootNodeUnsafe ::
+                  (MonadIO m, HasCallStack) => ScriptProfile -> m ScriptProfileNode
+getRootNodeUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getRootNode (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/ScriptProfile.rootNode Mozilla ScriptProfile.rootNode documentation> 
 getRootNodeUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/ScriptProfileNode.hs b/src/GHCJS/DOM/JSFFI/Generated/ScriptProfileNode.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/ScriptProfileNode.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/ScriptProfileNode.hs
@@ -1,12 +1,17 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.ScriptProfileNode
        (js_children, children, children_, js_getId, getId,
         js_getFunctionName, getFunctionName, js_getUrl, getUrl,
         js_getLineNumber, getLineNumber, js_getColumnNumber,
-        getColumnNumber, ScriptProfileNode, castToScriptProfileNode,
-        gTypeScriptProfileNode)
+        getColumnNumber, ScriptProfileNode(..), gTypeScriptProfileNode)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -22,6 +27,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"children\"]()" js_children
         :: ScriptProfileNode -> IO JSVal
diff --git a/src/GHCJS/DOM/JSFFI/Generated/SecurityPolicy.hs b/src/GHCJS/DOM/JSFFI/Generated/SecurityPolicy.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/SecurityPolicy.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/SecurityPolicy.hs
@@ -1,4 +1,9 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.SecurityPolicy
        (js_allowsConnectionTo, allowsConnectionTo, allowsConnectionTo_,
         js_allowsFontFrom, allowsFontFrom, allowsFontFrom_,
@@ -13,10 +18,11 @@
         js_getAllowsEval, getAllowsEval, js_getAllowsInlineScript,
         getAllowsInlineScript, js_getAllowsInlineStyle,
         getAllowsInlineStyle, js_getIsActive, getIsActive,
-        js_getReportURIs, getReportURIs, getReportURIsUnchecked,
-        SecurityPolicy, castToSecurityPolicy, gTypeSecurityPolicy)
+        js_getReportURIs, getReportURIs, getReportURIsUnsafe,
+        getReportURIsUnchecked, SecurityPolicy(..), gTypeSecurityPolicy)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -32,6 +38,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe
         "($1[\"allowsConnectionTo\"]($2) ? 1 : 0)" js_allowsConnectionTo ::
@@ -232,6 +248,14 @@
               (MonadIO m) => SecurityPolicy -> m (Maybe DOMStringList)
 getReportURIs self
   = liftIO (nullableToMaybe <$> (js_getReportURIs (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SecurityPolicy.reportURIs Mozilla SecurityPolicy.reportURIs documentation> 
+getReportURIsUnsafe ::
+                    (MonadIO m, HasCallStack) => SecurityPolicy -> m DOMStringList
+getReportURIsUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getReportURIs (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SecurityPolicy.reportURIs Mozilla SecurityPolicy.reportURIs documentation> 
 getReportURIsUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/SecurityPolicyViolationEvent.hs b/src/GHCJS/DOM/JSFFI/Generated/SecurityPolicyViolationEvent.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/SecurityPolicyViolationEvent.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/SecurityPolicyViolationEvent.hs
@@ -1,14 +1,20 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.SecurityPolicyViolationEvent
        (js_getDocumentURI, getDocumentURI, js_getReferrer, getReferrer,
         js_getBlockedURI, getBlockedURI, js_getViolatedDirective,
         getViolatedDirective, js_getEffectiveDirective,
         getEffectiveDirective, js_getOriginalPolicy, getOriginalPolicy,
         js_getSourceFile, getSourceFile, js_getLineNumber, getLineNumber,
-        SecurityPolicyViolationEvent, castToSecurityPolicyViolationEvent,
+        SecurityPolicyViolationEvent(..),
         gTypeSecurityPolicyViolationEvent)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -24,6 +30,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"documentURI\"]"
         js_getDocumentURI :: SecurityPolicyViolationEvent -> IO JSString
diff --git a/src/GHCJS/DOM/JSFFI/Generated/Selection.hs b/src/GHCJS/DOM/JSFFI/Generated/Selection.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/Selection.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/Selection.hs
@@ -1,24 +1,31 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.Selection
        (js_collapse, collapse, js_collapseToEnd, collapseToEnd,
         js_collapseToStart, collapseToStart, js_deleteFromDocument,
         deleteFromDocument, js_containsNode, containsNode, containsNode_,
         js_selectAllChildren, selectAllChildren, js_extend, extend,
-        js_getRangeAt, getRangeAt, getRangeAt_, getRangeAtUnchecked,
-        js_removeAllRanges, removeAllRanges, js_addRange, addRange,
-        js_toString, toString, toString_, js_modify, modify,
-        js_setBaseAndExtent, setBaseAndExtent, js_setPosition, setPosition,
-        js_empty, empty, js_getAnchorNode, getAnchorNode,
-        getAnchorNodeUnchecked, js_getAnchorOffset, getAnchorOffset,
-        js_getFocusNode, getFocusNode, getFocusNodeUnchecked,
-        js_getFocusOffset, getFocusOffset, js_getIsCollapsed,
-        getIsCollapsed, js_getRangeCount, getRangeCount, js_getBaseNode,
-        getBaseNode, getBaseNodeUnchecked, js_getBaseOffset, getBaseOffset,
-        js_getExtentNode, getExtentNode, getExtentNodeUnchecked,
-        js_getExtentOffset, getExtentOffset, js_getType, getType,
-        Selection, castToSelection, gTypeSelection)
+        js_getRangeAt, getRangeAt, getRangeAt_, getRangeAtUnsafe,
+        getRangeAtUnchecked, js_removeAllRanges, removeAllRanges,
+        js_addRange, addRange, js_toString, toString, toString_, js_modify,
+        modify, js_setBaseAndExtent, setBaseAndExtent, js_setPosition,
+        setPosition, js_empty, empty, js_getAnchorNode, getAnchorNode,
+        getAnchorNodeUnsafe, getAnchorNodeUnchecked, js_getAnchorOffset,
+        getAnchorOffset, js_getFocusNode, getFocusNode, getFocusNodeUnsafe,
+        getFocusNodeUnchecked, js_getFocusOffset, getFocusOffset,
+        js_getIsCollapsed, getIsCollapsed, js_getRangeCount, getRangeCount,
+        js_getBaseNode, getBaseNode, getBaseNodeUnsafe,
+        getBaseNodeUnchecked, js_getBaseOffset, getBaseOffset,
+        js_getExtentNode, getExtentNode, getExtentNodeUnsafe,
+        getExtentNodeUnchecked, js_getExtentOffset, getExtentOffset,
+        js_getType, getType, Selection(..), gTypeSelection)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -34,6 +41,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"collapse\"]($2, $3)"
         js_collapse :: Selection -> Nullable Node -> Int -> IO ()
@@ -121,6 +138,14 @@
 getRangeAt_ self index = liftIO (void (js_getRangeAt (self) index))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Selection.getRangeAt Mozilla Selection.getRangeAt documentation> 
+getRangeAtUnsafe ::
+                 (MonadIO m, HasCallStack) => Selection -> Int -> m Range
+getRangeAtUnsafe self index
+  = liftIO
+      ((nullableToMaybe <$> (js_getRangeAt (self) index)) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Selection.getRangeAt Mozilla Selection.getRangeAt documentation> 
 getRangeAtUnchecked :: (MonadIO m) => Selection -> Int -> m Range
 getRangeAtUnchecked self index
   = liftIO
@@ -209,6 +234,14 @@
   = liftIO (nullableToMaybe <$> (js_getAnchorNode (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Selection.anchorNode Mozilla Selection.anchorNode documentation> 
+getAnchorNodeUnsafe ::
+                    (MonadIO m, HasCallStack) => Selection -> m Node
+getAnchorNodeUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getAnchorNode (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Selection.anchorNode Mozilla Selection.anchorNode documentation> 
 getAnchorNodeUnchecked :: (MonadIO m) => Selection -> m Node
 getAnchorNodeUnchecked self
   = liftIO (fromJust . nullableToMaybe <$> (js_getAnchorNode (self)))
@@ -229,6 +262,14 @@
   = liftIO (nullableToMaybe <$> (js_getFocusNode (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Selection.focusNode Mozilla Selection.focusNode documentation> 
+getFocusNodeUnsafe ::
+                   (MonadIO m, HasCallStack) => Selection -> m Node
+getFocusNodeUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getFocusNode (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Selection.focusNode Mozilla Selection.focusNode documentation> 
 getFocusNodeUnchecked :: (MonadIO m) => Selection -> m Node
 getFocusNodeUnchecked self
   = liftIO (fromJust . nullableToMaybe <$> (js_getFocusNode (self)))
@@ -263,6 +304,14 @@
   = liftIO (nullableToMaybe <$> (js_getBaseNode (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Selection.baseNode Mozilla Selection.baseNode documentation> 
+getBaseNodeUnsafe ::
+                  (MonadIO m, HasCallStack) => Selection -> m Node
+getBaseNodeUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getBaseNode (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Selection.baseNode Mozilla Selection.baseNode documentation> 
 getBaseNodeUnchecked :: (MonadIO m) => Selection -> m Node
 getBaseNodeUnchecked self
   = liftIO (fromJust . nullableToMaybe <$> (js_getBaseNode (self)))
@@ -281,6 +330,14 @@
 getExtentNode :: (MonadIO m) => Selection -> m (Maybe Node)
 getExtentNode self
   = liftIO (nullableToMaybe <$> (js_getExtentNode (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Selection.extentNode Mozilla Selection.extentNode documentation> 
+getExtentNodeUnsafe ::
+                    (MonadIO m, HasCallStack) => Selection -> m Node
+getExtentNodeUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getExtentNode (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Selection.extentNode Mozilla Selection.extentNode documentation> 
 getExtentNodeUnchecked :: (MonadIO m) => Selection -> m Node
diff --git a/src/GHCJS/DOM/JSFFI/Generated/SourceBuffer.hs b/src/GHCJS/DOM/JSFFI/Generated/SourceBuffer.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/SourceBuffer.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/SourceBuffer.hs
@@ -1,20 +1,27 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.SourceBuffer
        (js_appendBuffer, appendBuffer, js_appendBufferView,
         appendBufferView, js_abort, abort, js_remove, remove, js_setMode,
         setMode, js_getMode, getMode, js_getUpdating, getUpdating,
-        js_getBuffered, getBuffered, getBufferedUnchecked,
-        js_setTimestampOffset, setTimestampOffset, js_getTimestampOffset,
-        getTimestampOffset, js_getAudioTracks, getAudioTracks,
-        getAudioTracksUnchecked, js_getVideoTracks, getVideoTracks,
+        js_getBuffered, getBuffered, getBufferedUnsafe,
+        getBufferedUnchecked, js_setTimestampOffset, setTimestampOffset,
+        js_getTimestampOffset, getTimestampOffset, js_getAudioTracks,
+        getAudioTracks, getAudioTracksUnsafe, getAudioTracksUnchecked,
+        js_getVideoTracks, getVideoTracks, getVideoTracksUnsafe,
         getVideoTracksUnchecked, js_getTextTracks, getTextTracks,
-        getTextTracksUnchecked, js_setAppendWindowStart,
-        setAppendWindowStart, js_getAppendWindowStart,
-        getAppendWindowStart, js_setAppendWindowEnd, setAppendWindowEnd,
-        js_getAppendWindowEnd, getAppendWindowEnd, SourceBuffer,
-        castToSourceBuffer, gTypeSourceBuffer)
+        getTextTracksUnsafe, getTextTracksUnchecked,
+        js_setAppendWindowStart, setAppendWindowStart,
+        js_getAppendWindowStart, getAppendWindowStart,
+        js_setAppendWindowEnd, setAppendWindowEnd, js_getAppendWindowEnd,
+        getAppendWindowEnd, SourceBuffer(..), gTypeSourceBuffer)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -30,6 +37,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"appendBuffer\"]($2)"
         js_appendBuffer :: SourceBuffer -> Nullable ArrayBuffer -> IO ()
@@ -100,6 +117,14 @@
   = liftIO (nullableToMaybe <$> (js_getBuffered (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SourceBuffer.buffered Mozilla SourceBuffer.buffered documentation> 
+getBufferedUnsafe ::
+                  (MonadIO m, HasCallStack) => SourceBuffer -> m TimeRanges
+getBufferedUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getBuffered (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SourceBuffer.buffered Mozilla SourceBuffer.buffered documentation> 
 getBufferedUnchecked :: (MonadIO m) => SourceBuffer -> m TimeRanges
 getBufferedUnchecked self
   = liftIO (fromJust . nullableToMaybe <$> (js_getBuffered (self)))
@@ -129,6 +154,14 @@
   = liftIO (nullableToMaybe <$> (js_getAudioTracks (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SourceBuffer.audioTracks Mozilla SourceBuffer.audioTracks documentation> 
+getAudioTracksUnsafe ::
+                     (MonadIO m, HasCallStack) => SourceBuffer -> m AudioTrackList
+getAudioTracksUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getAudioTracks (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SourceBuffer.audioTracks Mozilla SourceBuffer.audioTracks documentation> 
 getAudioTracksUnchecked ::
                         (MonadIO m) => SourceBuffer -> m AudioTrackList
 getAudioTracksUnchecked self
@@ -145,6 +178,14 @@
   = liftIO (nullableToMaybe <$> (js_getVideoTracks (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SourceBuffer.videoTracks Mozilla SourceBuffer.videoTracks documentation> 
+getVideoTracksUnsafe ::
+                     (MonadIO m, HasCallStack) => SourceBuffer -> m VideoTrackList
+getVideoTracksUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getVideoTracks (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SourceBuffer.videoTracks Mozilla SourceBuffer.videoTracks documentation> 
 getVideoTracksUnchecked ::
                         (MonadIO m) => SourceBuffer -> m VideoTrackList
 getVideoTracksUnchecked self
@@ -159,6 +200,14 @@
               (MonadIO m) => SourceBuffer -> m (Maybe TextTrackList)
 getTextTracks self
   = liftIO (nullableToMaybe <$> (js_getTextTracks (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SourceBuffer.textTracks Mozilla SourceBuffer.textTracks documentation> 
+getTextTracksUnsafe ::
+                    (MonadIO m, HasCallStack) => SourceBuffer -> m TextTrackList
+getTextTracksUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getTextTracks (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SourceBuffer.textTracks Mozilla SourceBuffer.textTracks documentation> 
 getTextTracksUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/SourceBufferList.hs b/src/GHCJS/DOM/JSFFI/Generated/SourceBufferList.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/SourceBufferList.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/SourceBufferList.hs
@@ -1,9 +1,15 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.SourceBufferList
-       (js_item, item, item_, itemUnchecked, js_getLength, getLength,
-        SourceBufferList, castToSourceBufferList, gTypeSourceBufferList)
+       (js_item, item, item_, itemUnsafe, itemUnchecked, js_getLength,
+        getLength, SourceBufferList(..), gTypeSourceBufferList)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -19,6 +25,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"item\"]($2)" js_item ::
         SourceBufferList -> Word -> IO (Nullable SourceBuffer)
@@ -32,6 +48,15 @@
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SourceBufferList.item Mozilla SourceBufferList.item documentation> 
 item_ :: (MonadIO m) => SourceBufferList -> Word -> m ()
 item_ self index = liftIO (void (js_item (self) index))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SourceBufferList.item Mozilla SourceBufferList.item documentation> 
+itemUnsafe ::
+           (MonadIO m, HasCallStack) =>
+             SourceBufferList -> Word -> m SourceBuffer
+itemUnsafe self index
+  = liftIO
+      ((nullableToMaybe <$> (js_item (self) index)) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SourceBufferList.item Mozilla SourceBufferList.item documentation> 
 itemUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/SourceInfo.hs b/src/GHCJS/DOM/JSFFI/Generated/SourceInfo.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/SourceInfo.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/SourceInfo.hs
@@ -1,9 +1,15 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.SourceInfo
        (js_getSourceId, getSourceId, js_getKind, getKind, js_getLabel,
-        getLabel, SourceInfo, castToSourceInfo, gTypeSourceInfo)
+        getLabel, SourceInfo(..), gTypeSourceInfo)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -19,6 +25,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"sourceId\"]" js_getSourceId
         :: SourceInfo -> IO JSString
diff --git a/src/GHCJS/DOM/JSFFI/Generated/SpeechSynthesis.hs b/src/GHCJS/DOM/JSFFI/Generated/SpeechSynthesis.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/SpeechSynthesis.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/SpeechSynthesis.hs
@@ -1,11 +1,17 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.SpeechSynthesis
        (js_speak, speak, js_cancel, cancel, js_pause, pause, js_resume,
         resume, js_getVoices, getVoices, getVoices_, js_getPending,
         getPending, js_getSpeaking, getSpeaking, js_getPaused, getPaused,
-        SpeechSynthesis, castToSpeechSynthesis, gTypeSpeechSynthesis)
+        SpeechSynthesis(..), gTypeSpeechSynthesis)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -21,6 +27,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"speak\"]($2)" js_speak ::
         SpeechSynthesis -> Nullable SpeechSynthesisUtterance -> IO ()
diff --git a/src/GHCJS/DOM/JSFFI/Generated/SpeechSynthesisEvent.hs b/src/GHCJS/DOM/JSFFI/Generated/SpeechSynthesisEvent.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/SpeechSynthesisEvent.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/SpeechSynthesisEvent.hs
@@ -1,10 +1,16 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.SpeechSynthesisEvent
        (js_getCharIndex, getCharIndex, js_getElapsedTime, getElapsedTime,
-        js_getName, getName, SpeechSynthesisEvent,
-        castToSpeechSynthesisEvent, gTypeSpeechSynthesisEvent)
+        js_getName, getName, SpeechSynthesisEvent(..),
+        gTypeSpeechSynthesisEvent)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -20,6 +26,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"charIndex\"]"
         js_getCharIndex :: SpeechSynthesisEvent -> IO Word
diff --git a/src/GHCJS/DOM/JSFFI/Generated/SpeechSynthesisUtterance.hs b/src/GHCJS/DOM/JSFFI/Generated/SpeechSynthesisUtterance.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/SpeechSynthesisUtterance.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/SpeechSynthesisUtterance.hs
@@ -1,15 +1,21 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.SpeechSynthesisUtterance
        (js_newSpeechSynthesisUtterance, newSpeechSynthesisUtterance,
         js_setText, setText, js_getText, getText, js_setLang, setLang,
         js_getLang, getLang, js_setVoice, setVoice, js_getVoice, getVoice,
-        getVoiceUnchecked, js_setVolume, setVolume, js_getVolume,
-        getVolume, js_setRate, setRate, js_getRate, getRate, js_setPitch,
-        setPitch, js_getPitch, getPitch, start, end, error, pause, resume,
-        mark, boundary, SpeechSynthesisUtterance,
-        castToSpeechSynthesisUtterance, gTypeSpeechSynthesisUtterance)
+        getVoiceUnsafe, getVoiceUnchecked, js_setVolume, setVolume,
+        js_getVolume, getVolume, js_setRate, setRate, js_getRate, getRate,
+        js_setPitch, setPitch, js_getPitch, getPitch, start, end, error,
+        pause, resume, mark, boundary, SpeechSynthesisUtterance(..),
+        gTypeSpeechSynthesisUtterance)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -25,6 +31,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe
         "new window[\"SpeechSynthesisUtterance\"]($1)"
@@ -92,6 +108,15 @@
          (MonadIO m) =>
            SpeechSynthesisUtterance -> m (Maybe SpeechSynthesisVoice)
 getVoice self = liftIO (nullableToMaybe <$> (js_getVoice (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/SpeechSynthesisUtterance.voice Mozilla SpeechSynthesisUtterance.voice documentation> 
+getVoiceUnsafe ::
+               (MonadIO m, HasCallStack) =>
+                 SpeechSynthesisUtterance -> m SpeechSynthesisVoice
+getVoiceUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getVoice (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/SpeechSynthesisUtterance.voice Mozilla SpeechSynthesisUtterance.voice documentation> 
 getVoiceUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/SpeechSynthesisVoice.hs b/src/GHCJS/DOM/JSFFI/Generated/SpeechSynthesisVoice.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/SpeechSynthesisVoice.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/SpeechSynthesisVoice.hs
@@ -1,11 +1,16 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.SpeechSynthesisVoice
        (js_getVoiceURI, getVoiceURI, js_getName, getName, js_getLang,
         getLang, js_getLocalService, getLocalService, js_getDefault,
-        getDefault, SpeechSynthesisVoice, castToSpeechSynthesisVoice,
-        gTypeSpeechSynthesisVoice)
+        getDefault, SpeechSynthesisVoice(..), gTypeSpeechSynthesisVoice)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -21,6 +26,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"voiceURI\"]" js_getVoiceURI
         :: SpeechSynthesisVoice -> IO JSString
diff --git a/src/GHCJS/DOM/JSFFI/Generated/Storage.hs b/src/GHCJS/DOM/JSFFI/Generated/Storage.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/Storage.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/Storage.hs
@@ -1,11 +1,17 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.Storage
-       (js_key, key, key_, keyUnchecked, js_getItem, getItem, getItem_,
-        getItemUnchecked, js_setItem, setItem, js_removeItem, removeItem,
-        js_clear, clear, js_getLength, getLength, Storage, castToStorage,
-        gTypeStorage)
+       (js_key, key, key_, keyUnsafe, keyUnchecked, js_getItem, getItem,
+        getItem_, getItemUnsafe, getItemUnchecked, js_setItem, setItem,
+        js_removeItem, removeItem, js_clear, clear, js_getLength,
+        getLength, Storage(..), gTypeStorage)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -21,6 +27,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"key\"]($2)" js_key ::
         Storage -> Word -> IO (Nullable JSString)
@@ -37,6 +53,15 @@
 key_ self index = liftIO (void (js_key (self) index))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Storage.key Mozilla Storage.key documentation> 
+keyUnsafe ::
+          (MonadIO m, HasCallStack, FromJSString result) =>
+            Storage -> Word -> m result
+keyUnsafe self index
+  = liftIO
+      ((fromMaybeJSString <$> (js_key (self) index)) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Storage.key Mozilla Storage.key documentation> 
 keyUnchecked ::
              (MonadIO m, FromJSString result) => Storage -> Word -> m result
 keyUnchecked self index
@@ -57,6 +82,15 @@
 getItem_ :: (MonadIO m, ToJSString key) => Storage -> key -> m ()
 getItem_ self key
   = liftIO (void (js_getItem (self) (toJSString key)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Storage.getItem Mozilla Storage.getItem documentation> 
+getItemUnsafe ::
+              (MonadIO m, ToJSString key, HasCallStack, FromJSString result) =>
+                Storage -> key -> m result
+getItemUnsafe self key
+  = liftIO
+      ((fromMaybeJSString <$> (js_getItem (self) (toJSString key))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Storage.getItem Mozilla Storage.getItem documentation> 
 getItemUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/StorageErrorCallback.hs b/src/GHCJS/DOM/JSFFI/Generated/StorageErrorCallback.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/StorageErrorCallback.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/StorageErrorCallback.hs
@@ -1,9 +1,15 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.StorageErrorCallback
        (newStorageErrorCallback, newStorageErrorCallbackSync,
         newStorageErrorCallbackAsync, StorageErrorCallback)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -19,6 +25,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/StorageErrorCallback Mozilla StorageErrorCallback documentation> 
 newStorageErrorCallback ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/StorageEvent.hs b/src/GHCJS/DOM/JSFFI/Generated/StorageEvent.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/StorageEvent.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/StorageEvent.hs
@@ -1,12 +1,19 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.StorageEvent
        (js_initStorageEvent, initStorageEvent, js_getKey, getKey,
-        js_getOldValue, getOldValue, getOldValueUnchecked, js_getNewValue,
-        getNewValue, getNewValueUnchecked, js_getUrl, getUrl,
-        js_getStorageArea, getStorageArea, getStorageAreaUnchecked,
-        StorageEvent, castToStorageEvent, gTypeStorageEvent)
+        js_getOldValue, getOldValue, getOldValueUnsafe,
+        getOldValueUnchecked, js_getNewValue, getNewValue,
+        getNewValueUnsafe, getNewValueUnchecked, js_getUrl, getUrl,
+        js_getStorageArea, getStorageArea, getStorageAreaUnsafe,
+        getStorageAreaUnchecked, StorageEvent(..), gTypeStorageEvent)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -22,6 +29,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe
         "$1[\"initStorageEvent\"]($2, $3,\n$4, $5, $6, $7, $8, $9)"
@@ -76,6 +93,15 @@
   = liftIO (fromMaybeJSString <$> (js_getOldValue (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/StorageEvent.oldValue Mozilla StorageEvent.oldValue documentation> 
+getOldValueUnsafe ::
+                  (MonadIO m, HasCallStack, FromJSString result) =>
+                    StorageEvent -> m result
+getOldValueUnsafe self
+  = liftIO
+      ((fromMaybeJSString <$> (js_getOldValue (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/StorageEvent.oldValue Mozilla StorageEvent.oldValue documentation> 
 getOldValueUnchecked ::
                      (MonadIO m, FromJSString result) => StorageEvent -> m result
 getOldValueUnchecked self
@@ -92,6 +118,15 @@
   = liftIO (fromMaybeJSString <$> (js_getNewValue (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/StorageEvent.newValue Mozilla StorageEvent.newValue documentation> 
+getNewValueUnsafe ::
+                  (MonadIO m, HasCallStack, FromJSString result) =>
+                    StorageEvent -> m result
+getNewValueUnsafe self
+  = liftIO
+      ((fromMaybeJSString <$> (js_getNewValue (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/StorageEvent.newValue Mozilla StorageEvent.newValue documentation> 
 getNewValueUnchecked ::
                      (MonadIO m, FromJSString result) => StorageEvent -> m result
 getNewValueUnchecked self
@@ -112,6 +147,14 @@
 getStorageArea :: (MonadIO m) => StorageEvent -> m (Maybe Storage)
 getStorageArea self
   = liftIO (nullableToMaybe <$> (js_getStorageArea (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/StorageEvent.storageArea Mozilla StorageEvent.storageArea documentation> 
+getStorageAreaUnsafe ::
+                     (MonadIO m, HasCallStack) => StorageEvent -> m Storage
+getStorageAreaUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getStorageArea (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/StorageEvent.storageArea Mozilla StorageEvent.storageArea documentation> 
 getStorageAreaUnchecked :: (MonadIO m) => StorageEvent -> m Storage
diff --git a/src/GHCJS/DOM/JSFFI/Generated/StorageInfo.hs b/src/GHCJS/DOM/JSFFI/Generated/StorageInfo.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/StorageInfo.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/StorageInfo.hs
@@ -1,10 +1,16 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.StorageInfo
        (js_queryUsageAndQuota, queryUsageAndQuota, js_requestQuota,
-        requestQuota, pattern TEMPORARY, pattern PERSISTENT, StorageInfo,
-        castToStorageInfo, gTypeStorageInfo)
+        requestQuota, pattern TEMPORARY, pattern PERSISTENT,
+        StorageInfo(..), gTypeStorageInfo)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -20,6 +26,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe
         "$1[\"queryUsageAndQuota\"]($2, $3,\n$4)" js_queryUsageAndQuota ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/StorageQuota.hs b/src/GHCJS/DOM/JSFFI/Generated/StorageQuota.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/StorageQuota.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/StorageQuota.hs
@@ -1,9 +1,15 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.StorageQuota
        (js_queryUsageAndQuota, queryUsageAndQuota, js_requestQuota,
-        requestQuota, StorageQuota, castToStorageQuota, gTypeStorageQuota)
+        requestQuota, StorageQuota(..), gTypeStorageQuota)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -19,6 +25,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe
         "$1[\"queryUsageAndQuota\"]($2, $3)" js_queryUsageAndQuota ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/StorageQuotaCallback.hs b/src/GHCJS/DOM/JSFFI/Generated/StorageQuotaCallback.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/StorageQuotaCallback.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/StorageQuotaCallback.hs
@@ -1,9 +1,15 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.StorageQuotaCallback
        (newStorageQuotaCallback, newStorageQuotaCallbackSync,
         newStorageQuotaCallbackAsync, StorageQuotaCallback)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -19,6 +25,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/StorageQuotaCallback Mozilla StorageQuotaCallback documentation> 
 newStorageQuotaCallback ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/StorageUsageCallback.hs b/src/GHCJS/DOM/JSFFI/Generated/StorageUsageCallback.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/StorageUsageCallback.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/StorageUsageCallback.hs
@@ -1,9 +1,15 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.StorageUsageCallback
        (newStorageUsageCallback, newStorageUsageCallbackSync,
         newStorageUsageCallbackAsync, StorageUsageCallback)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -19,6 +25,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/StorageUsageCallback Mozilla StorageUsageCallback documentation> 
 newStorageUsageCallback ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/StringCallback.hs b/src/GHCJS/DOM/JSFFI/Generated/StringCallback.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/StringCallback.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/StringCallback.hs
@@ -1,9 +1,15 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.StringCallback
        (newStringCallback, newStringCallbackSync, newStringCallbackAsync,
         StringCallback)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -19,6 +25,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/StringCallback Mozilla StringCallback documentation> 
 newStringCallback ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/StyleMedia.hs b/src/GHCJS/DOM/JSFFI/Generated/StyleMedia.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/StyleMedia.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/StyleMedia.hs
@@ -1,9 +1,15 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.StyleMedia
        (js_matchMedium, matchMedium, matchMedium_, js_getType, getType,
-        StyleMedia, castToStyleMedia, gTypeStyleMedia)
+        StyleMedia(..), gTypeStyleMedia)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -19,6 +25,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe
         "($1[\"matchMedium\"]($2) ? 1 : 0)" js_matchMedium ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/StyleSheet.hs b/src/GHCJS/DOM/JSFFI/Generated/StyleSheet.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/StyleSheet.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/StyleSheet.hs
@@ -1,15 +1,22 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.StyleSheet
-       (js_getType, getType, getTypeUnchecked, js_setDisabled,
-        setDisabled, js_getDisabled, getDisabled, js_getOwnerNode,
-        getOwnerNode, getOwnerNodeUnchecked, js_getParentStyleSheet,
-        getParentStyleSheet, getParentStyleSheetUnchecked, js_getHref,
-        getHref, getHrefUnchecked, js_getTitle, getTitle,
-        getTitleUnchecked, js_getMedia, getMedia, getMediaUnchecked,
-        StyleSheet, castToStyleSheet, gTypeStyleSheet, IsStyleSheet,
-        toStyleSheet)
+       (js_getType, getType, getTypeUnsafe, getTypeUnchecked,
+        js_setDisabled, setDisabled, js_getDisabled, getDisabled,
+        js_getOwnerNode, getOwnerNode, getOwnerNodeUnsafe,
+        getOwnerNodeUnchecked, js_getParentStyleSheet, getParentStyleSheet,
+        getParentStyleSheetUnsafe, getParentStyleSheetUnchecked,
+        js_getHref, getHref, getHrefUnsafe, getHrefUnchecked, js_getTitle,
+        getTitle, getTitleUnsafe, getTitleUnchecked, js_getMedia, getMedia,
+        getMediaUnsafe, getMediaUnchecked, StyleSheet(..), gTypeStyleSheet,
+        IsStyleSheet, toStyleSheet)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -25,6 +32,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"type\"]" js_getType ::
         StyleSheet -> IO (Nullable JSString)
@@ -37,6 +54,16 @@
   = liftIO (fromMaybeJSString <$> (js_getType (toStyleSheet self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/StyleSheet.type Mozilla StyleSheet.type documentation> 
+getTypeUnsafe ::
+              (MonadIO m, IsStyleSheet self, HasCallStack,
+               FromJSString result) =>
+                self -> m result
+getTypeUnsafe self
+  = liftIO
+      ((fromMaybeJSString <$> (js_getType (toStyleSheet self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/StyleSheet.type Mozilla StyleSheet.type documentation> 
 getTypeUnchecked ::
                  (MonadIO m, IsStyleSheet self, FromJSString result) =>
                    self -> m result
@@ -71,6 +98,14 @@
       (nullableToMaybe <$> (js_getOwnerNode (toStyleSheet self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/StyleSheet.ownerNode Mozilla StyleSheet.ownerNode documentation> 
+getOwnerNodeUnsafe ::
+                   (MonadIO m, IsStyleSheet self, HasCallStack) => self -> m Node
+getOwnerNodeUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getOwnerNode (toStyleSheet self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/StyleSheet.ownerNode Mozilla StyleSheet.ownerNode documentation> 
 getOwnerNodeUnchecked ::
                       (MonadIO m, IsStyleSheet self) => self -> m Node
 getOwnerNodeUnchecked self
@@ -89,6 +124,15 @@
       (nullableToMaybe <$> (js_getParentStyleSheet (toStyleSheet self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/StyleSheet.parentStyleSheet Mozilla StyleSheet.parentStyleSheet documentation> 
+getParentStyleSheetUnsafe ::
+                          (MonadIO m, IsStyleSheet self, HasCallStack) =>
+                            self -> m StyleSheet
+getParentStyleSheetUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getParentStyleSheet (toStyleSheet self)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/StyleSheet.parentStyleSheet Mozilla StyleSheet.parentStyleSheet documentation> 
 getParentStyleSheetUnchecked ::
                              (MonadIO m, IsStyleSheet self) => self -> m StyleSheet
 getParentStyleSheetUnchecked self
@@ -107,6 +151,16 @@
   = liftIO (fromMaybeJSString <$> (js_getHref (toStyleSheet self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/StyleSheet.href Mozilla StyleSheet.href documentation> 
+getHrefUnsafe ::
+              (MonadIO m, IsStyleSheet self, HasCallStack,
+               FromJSString result) =>
+                self -> m result
+getHrefUnsafe self
+  = liftIO
+      ((fromMaybeJSString <$> (js_getHref (toStyleSheet self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/StyleSheet.href Mozilla StyleSheet.href documentation> 
 getHrefUnchecked ::
                  (MonadIO m, IsStyleSheet self, FromJSString result) =>
                    self -> m result
@@ -125,6 +179,16 @@
   = liftIO (fromMaybeJSString <$> (js_getTitle (toStyleSheet self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/StyleSheet.title Mozilla StyleSheet.title documentation> 
+getTitleUnsafe ::
+               (MonadIO m, IsStyleSheet self, HasCallStack,
+                FromJSString result) =>
+                 self -> m result
+getTitleUnsafe self
+  = liftIO
+      ((fromMaybeJSString <$> (js_getTitle (toStyleSheet self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/StyleSheet.title Mozilla StyleSheet.title documentation> 
 getTitleUnchecked ::
                   (MonadIO m, IsStyleSheet self, FromJSString result) =>
                     self -> m result
@@ -141,6 +205,14 @@
          (MonadIO m, IsStyleSheet self) => self -> m (Maybe MediaList)
 getMedia self
   = liftIO (nullableToMaybe <$> (js_getMedia (toStyleSheet self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/StyleSheet.media Mozilla StyleSheet.media documentation> 
+getMediaUnsafe ::
+               (MonadIO m, IsStyleSheet self, HasCallStack) => self -> m MediaList
+getMediaUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getMedia (toStyleSheet self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/StyleSheet.media Mozilla StyleSheet.media documentation> 
 getMediaUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/StyleSheetList.hs b/src/GHCJS/DOM/JSFFI/Generated/StyleSheetList.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/StyleSheetList.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/StyleSheetList.hs
@@ -1,10 +1,16 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.StyleSheetList
-       (js_item, item, item_, itemUnchecked, js__get, _get, _get_,
-        _getUnchecked, js_getLength, getLength, StyleSheetList,
-        castToStyleSheetList, gTypeStyleSheetList)
+       (js_item, item, item_, itemUnsafe, itemUnchecked, js__get, _get,
+        _get_, _getUnsafe, _getUnchecked, js_getLength, getLength,
+        StyleSheetList(..), gTypeStyleSheetList)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -20,6 +26,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"item\"]($2)" js_item ::
         StyleSheetList -> Word -> IO (Nullable StyleSheet)
@@ -35,6 +51,14 @@
 item_ self index = liftIO (void (js_item (self) index))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/StyleSheetList.item Mozilla StyleSheetList.item documentation> 
+itemUnsafe ::
+           (MonadIO m, HasCallStack) => StyleSheetList -> Word -> m StyleSheet
+itemUnsafe self index
+  = liftIO
+      ((nullableToMaybe <$> (js_item (self) index)) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/StyleSheetList.item Mozilla StyleSheetList.item documentation> 
 itemUnchecked ::
               (MonadIO m) => StyleSheetList -> Word -> m StyleSheet
 itemUnchecked self index
@@ -54,6 +78,15 @@
 _get_ ::
       (MonadIO m, ToJSString name) => StyleSheetList -> name -> m ()
 _get_ self name = liftIO (void (js__get (self) (toJSString name)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/StyleSheetList._get Mozilla StyleSheetList._get documentation> 
+_getUnsafe ::
+           (MonadIO m, ToJSString name, HasCallStack) =>
+             StyleSheetList -> name -> m CSSStyleSheet
+_getUnsafe self name
+  = liftIO
+      ((nullableToMaybe <$> (js__get (self) (toJSString name))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/StyleSheetList._get Mozilla StyleSheetList._get documentation> 
 _getUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/SubtleCrypto.hs b/src/GHCJS/DOM/JSFFI/Generated/SubtleCrypto.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/SubtleCrypto.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/SubtleCrypto.hs
@@ -1,17 +1,25 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.SubtleCrypto
-       (js_encrypt, encrypt, encrypt_, encryptUnchecked, js_decrypt,
-        decrypt, decrypt_, decryptUnchecked, js_sign, sign, sign_,
-        signUnchecked, js_verify, verify, verify_, verifyUnchecked,
-        js_digest, digest, digest_, digestUnchecked, js_generateKey,
-        generateKey, generateKey_, generateKeyUnchecked, js_importKey,
-        importKey, importKey_, importKeyUnchecked, js_exportKey, exportKey,
-        exportKey_, exportKeyUnchecked, js_wrapKey, wrapKey, wrapKey_,
-        wrapKeyUnchecked, js_unwrapKey, unwrapKey, unwrapKey_,
-        unwrapKeyUnchecked, SubtleCrypto, castToSubtleCrypto,
+       (js_encrypt, encrypt, encrypt_, encryptUnsafe, encryptUnchecked,
+        js_decrypt, decrypt, decrypt_, decryptUnsafe, decryptUnchecked,
+        js_sign, sign, sign_, signUnsafe, signUnchecked, js_verify, verify,
+        verify_, verifyUnsafe, verifyUnchecked, js_digest, digest, digest_,
+        digestUnsafe, digestUnchecked, js_generateKey, generateKey,
+        generateKey_, generateKeyUnsafe, generateKeyUnchecked,
+        js_importKey, importKey, importKey_, importKeyUnsafe,
+        importKeyUnchecked, js_exportKey, exportKey, exportKey_,
+        exportKeyUnsafe, exportKeyUnchecked, js_wrapKey, wrapKey, wrapKey_,
+        wrapKeyUnsafe, wrapKeyUnchecked, js_unwrapKey, unwrapKey,
+        unwrapKey_, unwrapKeyUnsafe, unwrapKeyUnchecked, SubtleCrypto(..),
         gTypeSubtleCrypto)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -27,6 +35,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"encrypt\"]($2, $3, $4)"
         js_encrypt ::
@@ -60,6 +78,21 @@
                 data''))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/WebKitSubtleCrypto.encrypt Mozilla WebKitSubtleCrypto.encrypt documentation> 
+encryptUnsafe ::
+              (MonadIO m, ToJSString algorithm, IsCryptoOperationData data',
+               HasCallStack) =>
+                SubtleCrypto ->
+                  algorithm -> Maybe CryptoKey -> [Maybe data'] -> m Promise
+encryptUnsafe self algorithm key data'
+  = liftIO
+      ((nullableToMaybe <$>
+          (toJSVal data' >>=
+             \ data'' ->
+               js_encrypt (self) (toJSString algorithm) (maybeToNullable key)
+                 data''))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/WebKitSubtleCrypto.encrypt Mozilla WebKitSubtleCrypto.encrypt documentation> 
 encryptUnchecked ::
                  (MonadIO m, ToJSString algorithm, IsCryptoOperationData data') =>
                    SubtleCrypto ->
@@ -104,6 +137,21 @@
                 data''))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/WebKitSubtleCrypto.decrypt Mozilla WebKitSubtleCrypto.decrypt documentation> 
+decryptUnsafe ::
+              (MonadIO m, ToJSString algorithm, IsCryptoOperationData data',
+               HasCallStack) =>
+                SubtleCrypto ->
+                  algorithm -> Maybe CryptoKey -> [Maybe data'] -> m Promise
+decryptUnsafe self algorithm key data'
+  = liftIO
+      ((nullableToMaybe <$>
+          (toJSVal data' >>=
+             \ data'' ->
+               js_decrypt (self) (toJSString algorithm) (maybeToNullable key)
+                 data''))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/WebKitSubtleCrypto.decrypt Mozilla WebKitSubtleCrypto.decrypt documentation> 
 decryptUnchecked ::
                  (MonadIO m, ToJSString algorithm, IsCryptoOperationData data') =>
                    SubtleCrypto ->
@@ -148,6 +196,21 @@
                 data''))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/WebKitSubtleCrypto.sign Mozilla WebKitSubtleCrypto.sign documentation> 
+signUnsafe ::
+           (MonadIO m, ToJSString algorithm, IsCryptoOperationData data',
+            HasCallStack) =>
+             SubtleCrypto ->
+               algorithm -> Maybe CryptoKey -> [Maybe data'] -> m Promise
+signUnsafe self algorithm key data'
+  = liftIO
+      ((nullableToMaybe <$>
+          (toJSVal data' >>=
+             \ data'' ->
+               js_sign (self) (toJSString algorithm) (maybeToNullable key)
+                 data''))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/WebKitSubtleCrypto.sign Mozilla WebKitSubtleCrypto.sign documentation> 
 signUnchecked ::
               (MonadIO m, ToJSString algorithm, IsCryptoOperationData data') =>
                 SubtleCrypto ->
@@ -201,6 +264,23 @@
                 data''))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/WebKitSubtleCrypto.verify Mozilla WebKitSubtleCrypto.verify documentation> 
+verifyUnsafe ::
+             (MonadIO m, ToJSString algorithm, IsCryptoOperationData signature,
+              IsCryptoOperationData data', HasCallStack) =>
+               SubtleCrypto ->
+                 algorithm ->
+                   Maybe CryptoKey -> Maybe signature -> [Maybe data'] -> m Promise
+verifyUnsafe self algorithm key signature data'
+  = liftIO
+      ((nullableToMaybe <$>
+          (toJSVal data' >>=
+             \ data'' ->
+               js_verify (self) (toJSString algorithm) (maybeToNullable key)
+                 (maybeToNullable (fmap toCryptoOperationData signature))
+                 data''))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/WebKitSubtleCrypto.verify Mozilla WebKitSubtleCrypto.verify documentation> 
 verifyUnchecked ::
                 (MonadIO m, ToJSString algorithm, IsCryptoOperationData signature,
                  IsCryptoOperationData data') =>
@@ -240,6 +320,18 @@
             \ data'' -> js_digest (self) (toJSString algorithm) data''))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/WebKitSubtleCrypto.digest Mozilla WebKitSubtleCrypto.digest documentation> 
+digestUnsafe ::
+             (MonadIO m, ToJSString algorithm, IsCryptoOperationData data',
+              HasCallStack) =>
+               SubtleCrypto -> algorithm -> [Maybe data'] -> m Promise
+digestUnsafe self algorithm data'
+  = liftIO
+      ((nullableToMaybe <$>
+          (toJSVal data' >>=
+             \ data'' -> js_digest (self) (toJSString algorithm) data''))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/WebKitSubtleCrypto.digest Mozilla WebKitSubtleCrypto.digest documentation> 
 digestUnchecked ::
                 (MonadIO m, ToJSString algorithm, IsCryptoOperationData data') =>
                   SubtleCrypto -> algorithm -> [Maybe data'] -> m Promise
@@ -279,6 +371,19 @@
                 keyUsages'))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/WebKitSubtleCrypto.generateKey Mozilla WebKitSubtleCrypto.generateKey documentation> 
+generateKeyUnsafe ::
+                  (MonadIO m, ToJSString algorithm, HasCallStack) =>
+                    SubtleCrypto -> algorithm -> Bool -> [KeyUsage] -> m Promise
+generateKeyUnsafe self algorithm extractable keyUsages
+  = liftIO
+      ((nullableToMaybe <$>
+          (toJSVal keyUsages >>=
+             \ keyUsages' ->
+               js_generateKey (self) (toJSString algorithm) extractable
+                 keyUsages'))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/WebKitSubtleCrypto.generateKey Mozilla WebKitSubtleCrypto.generateKey documentation> 
 generateKeyUnchecked ::
                      (MonadIO m, ToJSString algorithm) =>
                        SubtleCrypto -> algorithm -> Bool -> [KeyUsage] -> m Promise
@@ -334,6 +439,25 @@
                 keyUsages'))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/WebKitSubtleCrypto.importKey Mozilla WebKitSubtleCrypto.importKey documentation> 
+importKeyUnsafe ::
+                (MonadIO m, ToJSString format, IsCryptoOperationData keyData,
+                 ToJSString algorithm, HasCallStack) =>
+                  SubtleCrypto ->
+                    format ->
+                      Maybe keyData -> algorithm -> Bool -> [KeyUsage] -> m Promise
+importKeyUnsafe self format keyData algorithm extractable keyUsages
+  = liftIO
+      ((nullableToMaybe <$>
+          (toJSVal keyUsages >>=
+             \ keyUsages' ->
+               js_importKey (self) (toJSString format)
+                 (maybeToNullable (fmap toCryptoOperationData keyData))
+                 (toJSString algorithm)
+                 extractable
+                 keyUsages'))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/WebKitSubtleCrypto.importKey Mozilla WebKitSubtleCrypto.importKey documentation> 
 importKeyUnchecked ::
                    (MonadIO m, ToJSString format, IsCryptoOperationData keyData,
                     ToJSString algorithm) =>
@@ -376,6 +500,16 @@
          (js_exportKey (self) (toJSString format) (maybeToNullable key)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/WebKitSubtleCrypto.exportKey Mozilla WebKitSubtleCrypto.exportKey documentation> 
+exportKeyUnsafe ::
+                (MonadIO m, ToJSString format, HasCallStack) =>
+                  SubtleCrypto -> format -> Maybe CryptoKey -> m Promise
+exportKeyUnsafe self format key
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_exportKey (self) (toJSString format) (maybeToNullable key)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/WebKitSubtleCrypto.exportKey Mozilla WebKitSubtleCrypto.exportKey documentation> 
 exportKeyUnchecked ::
                    (MonadIO m, ToJSString format) =>
                      SubtleCrypto -> format -> Maybe CryptoKey -> m Promise
@@ -419,6 +553,21 @@
             (toJSString wrapAlgorithm)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/WebKitSubtleCrypto.wrapKey Mozilla WebKitSubtleCrypto.wrapKey documentation> 
+wrapKeyUnsafe ::
+              (MonadIO m, ToJSString format, ToJSString wrapAlgorithm,
+               HasCallStack) =>
+                SubtleCrypto ->
+                  format ->
+                    Maybe CryptoKey -> Maybe CryptoKey -> wrapAlgorithm -> m Promise
+wrapKeyUnsafe self format key wrappingKey wrapAlgorithm
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_wrapKey (self) (toJSString format) (maybeToNullable key)
+             (maybeToNullable wrappingKey)
+             (toJSString wrapAlgorithm)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/WebKitSubtleCrypto.wrapKey Mozilla WebKitSubtleCrypto.wrapKey documentation> 
 wrapKeyUnchecked ::
                  (MonadIO m, ToJSString format, ToJSString wrapAlgorithm) =>
                    SubtleCrypto ->
@@ -486,6 +635,32 @@
                 (toJSString unwrappedKeyAlgorithm)
                 extractable
                 keyUsages'))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/WebKitSubtleCrypto.unwrapKey Mozilla WebKitSubtleCrypto.unwrapKey documentation> 
+unwrapKeyUnsafe ::
+                (MonadIO m, ToJSString format, IsCryptoOperationData wrappedKey,
+                 ToJSString unwrapAlgorithm, ToJSString unwrappedKeyAlgorithm,
+                 HasCallStack) =>
+                  SubtleCrypto ->
+                    format ->
+                      Maybe wrappedKey ->
+                        Maybe CryptoKey ->
+                          unwrapAlgorithm ->
+                            unwrappedKeyAlgorithm -> Bool -> [KeyUsage] -> m Promise
+unwrapKeyUnsafe self format wrappedKey unwrappingKey
+  unwrapAlgorithm unwrappedKeyAlgorithm extractable keyUsages
+  = liftIO
+      ((nullableToMaybe <$>
+          (toJSVal keyUsages >>=
+             \ keyUsages' ->
+               js_unwrapKey (self) (toJSString format)
+                 (maybeToNullable (fmap toCryptoOperationData wrappedKey))
+                 (maybeToNullable unwrappingKey)
+                 (toJSString unwrapAlgorithm)
+                 (toJSString unwrappedKeyAlgorithm)
+                 extractable
+                 keyUsages'))
+         >>= maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/WebKitSubtleCrypto.unwrapKey Mozilla WebKitSubtleCrypto.unwrapKey documentation> 
 unwrapKeyUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/Text.hs b/src/GHCJS/DOM/JSFFI/Generated/Text.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/Text.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/Text.hs
@@ -1,11 +1,18 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.Text
        (js_newText, newText, js_splitText, splitText, splitText_,
-        splitTextUnchecked, js_replaceWholeText, replaceWholeText,
-        replaceWholeText_, replaceWholeTextUnchecked, js_getWholeText,
-        getWholeText, Text, castToText, gTypeText, IsText, toText)
+        splitTextUnsafe, splitTextUnchecked, js_replaceWholeText,
+        replaceWholeText, replaceWholeText_, replaceWholeTextUnsafe,
+        replaceWholeTextUnchecked, js_getWholeText, getWholeText, Text(..),
+        gTypeText, IsText, toText)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -21,6 +28,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "new window[\"Text\"]($1)"
         js_newText :: JSString -> IO Text
@@ -44,6 +61,14 @@
   = liftIO (void (js_splitText (toText self) offset))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Text.splitText Mozilla Text.splitText documentation> 
+splitTextUnsafe ::
+                (MonadIO m, IsText self, HasCallStack) => self -> Word -> m Text
+splitTextUnsafe self offset
+  = liftIO
+      ((nullableToMaybe <$> (js_splitText (toText self) offset)) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Text.splitText Mozilla Text.splitText documentation> 
 splitTextUnchecked ::
                    (MonadIO m, IsText self) => self -> Word -> m Text
 splitTextUnchecked self offset
@@ -70,6 +95,16 @@
 replaceWholeText_ self content
   = liftIO
       (void (js_replaceWholeText (toText self) (toJSString content)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Text.replaceWholeText Mozilla Text.replaceWholeText documentation> 
+replaceWholeTextUnsafe ::
+                       (MonadIO m, IsText self, ToJSString content, HasCallStack) =>
+                         self -> content -> m Text
+replaceWholeTextUnsafe self content
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_replaceWholeText (toText self) (toJSString content)))
+         >>= maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Text.replaceWholeText Mozilla Text.replaceWholeText documentation> 
 replaceWholeTextUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/TextEvent.hs b/src/GHCJS/DOM/JSFFI/Generated/TextEvent.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/TextEvent.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/TextEvent.hs
@@ -1,9 +1,15 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.TextEvent
-       (js_initTextEvent, initTextEvent, js_getData, getData, TextEvent,
-        castToTextEvent, gTypeTextEvent)
+       (js_initTextEvent, initTextEvent, js_getData, getData,
+        TextEvent(..), gTypeTextEvent)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -19,6 +25,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe
         "$1[\"initTextEvent\"]($2, $3, $4,\n$5, $6)" js_initTextEvent ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/TextMetrics.hs b/src/GHCJS/DOM/JSFFI/Generated/TextMetrics.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/TextMetrics.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/TextMetrics.hs
@@ -1,9 +1,13 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.TextMetrics
-       (js_getWidth, getWidth, TextMetrics, castToTextMetrics,
-        gTypeTextMetrics)
-       where
+       (js_getWidth, getWidth, TextMetrics(..), gTypeTextMetrics) where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -19,6 +23,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"width\"]" js_getWidth ::
         TextMetrics -> IO Float
diff --git a/src/GHCJS/DOM/JSFFI/Generated/TextTrack.hs b/src/GHCJS/DOM/JSFFI/Generated/TextTrack.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/TextTrack.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/TextTrack.hs
@@ -1,4 +1,9 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.TextTrack
        (js_addCue, addCue, js_removeCue, removeCue, js_addRegion,
         addRegion, js_removeRegion, removeRegion, js_getId, getId,
@@ -6,13 +11,15 @@
         js_setLanguage, setLanguage, js_getLanguage, getLanguage,
         js_getInBandMetadataTrackDispatchType,
         getInBandMetadataTrackDispatchType, js_setMode, setMode,
-        js_getMode, getMode, js_getCues, getCues, getCuesUnchecked,
-        js_getActiveCues, getActiveCues, getActiveCuesUnchecked, cueChange,
-        js_getRegions, getRegions, getRegionsUnchecked, js_getSourceBuffer,
-        getSourceBuffer, getSourceBufferUnchecked, TextTrack,
-        castToTextTrack, gTypeTextTrack)
+        js_getMode, getMode, js_getCues, getCues, getCuesUnsafe,
+        getCuesUnchecked, js_getActiveCues, getActiveCues,
+        getActiveCuesUnsafe, getActiveCuesUnchecked, cueChange,
+        js_getRegions, getRegions, getRegionsUnsafe, getRegionsUnchecked,
+        js_getSourceBuffer, getSourceBuffer, getSourceBufferUnsafe,
+        getSourceBufferUnchecked, TextTrack(..), gTypeTextTrack)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -28,6 +35,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"addCue\"]($2)" js_addCue ::
         TextTrack -> Nullable TextTrackCue -> IO ()
@@ -145,6 +162,14 @@
 getCues self = liftIO (nullableToMaybe <$> (js_getCues (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/TextTrack.cues Mozilla TextTrack.cues documentation> 
+getCuesUnsafe ::
+              (MonadIO m, HasCallStack) => TextTrack -> m TextTrackCueList
+getCuesUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getCues (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/TextTrack.cues Mozilla TextTrack.cues documentation> 
 getCuesUnchecked :: (MonadIO m) => TextTrack -> m TextTrackCueList
 getCuesUnchecked self
   = liftIO (fromJust . nullableToMaybe <$> (js_getCues (self)))
@@ -159,6 +184,14 @@
   = liftIO (nullableToMaybe <$> (js_getActiveCues (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/TextTrack.activeCues Mozilla TextTrack.activeCues documentation> 
+getActiveCuesUnsafe ::
+                    (MonadIO m, HasCallStack) => TextTrack -> m TextTrackCueList
+getActiveCuesUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getActiveCues (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/TextTrack.activeCues Mozilla TextTrack.activeCues documentation> 
 getActiveCuesUnchecked ::
                        (MonadIO m) => TextTrack -> m TextTrackCueList
 getActiveCuesUnchecked self
@@ -177,6 +210,14 @@
   = liftIO (nullableToMaybe <$> (js_getRegions (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/TextTrack.regions Mozilla TextTrack.regions documentation> 
+getRegionsUnsafe ::
+                 (MonadIO m, HasCallStack) => TextTrack -> m VTTRegionList
+getRegionsUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getRegions (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/TextTrack.regions Mozilla TextTrack.regions documentation> 
 getRegionsUnchecked :: (MonadIO m) => TextTrack -> m VTTRegionList
 getRegionsUnchecked self
   = liftIO (fromJust . nullableToMaybe <$> (js_getRegions (self)))
@@ -189,6 +230,14 @@
                 (MonadIO m) => TextTrack -> m (Maybe SourceBuffer)
 getSourceBuffer self
   = liftIO (nullableToMaybe <$> (js_getSourceBuffer (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/TextTrack.sourceBuffer Mozilla TextTrack.sourceBuffer documentation> 
+getSourceBufferUnsafe ::
+                      (MonadIO m, HasCallStack) => TextTrack -> m SourceBuffer
+getSourceBufferUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getSourceBuffer (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/TextTrack.sourceBuffer Mozilla TextTrack.sourceBuffer documentation> 
 getSourceBufferUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/TextTrackCue.hs b/src/GHCJS/DOM/JSFFI/Generated/TextTrackCue.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/TextTrackCue.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/TextTrackCue.hs
@@ -1,14 +1,20 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.TextTrackCue
        (js_newTextTrackCue, newTextTrackCue, js_getTrack, getTrack,
-        getTrackUnchecked, js_setId, setId, js_getId, getId,
-        js_setStartTime, setStartTime, js_getStartTime, getStartTime,
-        js_setEndTime, setEndTime, js_getEndTime, getEndTime,
+        getTrackUnsafe, getTrackUnchecked, js_setId, setId, js_getId,
+        getId, js_setStartTime, setStartTime, js_getStartTime,
+        getStartTime, js_setEndTime, setEndTime, js_getEndTime, getEndTime,
         js_setPauseOnExit, setPauseOnExit, js_getPauseOnExit,
-        getPauseOnExit, enter, exit, TextTrackCue, castToTextTrackCue,
-        gTypeTextTrackCue, IsTextTrackCue, toTextTrackCue)
+        getPauseOnExit, enter, exit, TextTrackCue(..), gTypeTextTrackCue,
+        IsTextTrackCue, toTextTrackCue)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -24,6 +30,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe
         "new window[\"TextTrackCue\"]($1,\n$2, $3)" js_newTextTrackCue ::
@@ -44,6 +60,15 @@
          (MonadIO m, IsTextTrackCue self) => self -> m (Maybe TextTrack)
 getTrack self
   = liftIO (nullableToMaybe <$> (js_getTrack (toTextTrackCue self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/TextTrackCue.track Mozilla TextTrackCue.track documentation> 
+getTrackUnsafe ::
+               (MonadIO m, IsTextTrackCue self, HasCallStack) =>
+                 self -> m TextTrack
+getTrackUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getTrack (toTextTrackCue self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/TextTrackCue.track Mozilla TextTrackCue.track documentation> 
 getTrackUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/TextTrackCueList.hs b/src/GHCJS/DOM/JSFFI/Generated/TextTrackCueList.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/TextTrackCueList.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/TextTrackCueList.hs
@@ -1,10 +1,17 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.TextTrackCueList
-       (js_item, item, item_, itemUnchecked, js_getCueById, getCueById,
-        getCueById_, getCueByIdUnchecked, js_getLength, getLength,
-        TextTrackCueList, castToTextTrackCueList, gTypeTextTrackCueList)
+       (js_item, item, item_, itemUnsafe, itemUnchecked, js_getCueById,
+        getCueById, getCueById_, getCueByIdUnsafe, getCueByIdUnchecked,
+        js_getLength, getLength, TextTrackCueList(..),
+        gTypeTextTrackCueList)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -20,6 +27,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"item\"]($2)" js_item ::
         TextTrackCueList -> Word -> IO (Nullable TextTrackCue)
@@ -35,6 +52,15 @@
 item_ self index = liftIO (void (js_item (self) index))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/TextTrackCueList.item Mozilla TextTrackCueList.item documentation> 
+itemUnsafe ::
+           (MonadIO m, HasCallStack) =>
+             TextTrackCueList -> Word -> m TextTrackCue
+itemUnsafe self index
+  = liftIO
+      ((nullableToMaybe <$> (js_item (self) index)) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/TextTrackCueList.item Mozilla TextTrackCueList.item documentation> 
 itemUnchecked ::
               (MonadIO m) => TextTrackCueList -> Word -> m TextTrackCue
 itemUnchecked self index
@@ -57,6 +83,15 @@
             (MonadIO m, ToJSString id) => TextTrackCueList -> id -> m ()
 getCueById_ self id
   = liftIO (void (js_getCueById (self) (toJSString id)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/TextTrackCueList.getCueById Mozilla TextTrackCueList.getCueById documentation> 
+getCueByIdUnsafe ::
+                 (MonadIO m, ToJSString id, HasCallStack) =>
+                   TextTrackCueList -> id -> m TextTrackCue
+getCueByIdUnsafe self id
+  = liftIO
+      ((nullableToMaybe <$> (js_getCueById (self) (toJSString id))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/TextTrackCueList.getCueById Mozilla TextTrackCueList.getCueById documentation> 
 getCueByIdUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/TextTrackList.hs b/src/GHCJS/DOM/JSFFI/Generated/TextTrackList.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/TextTrackList.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/TextTrackList.hs
@@ -1,11 +1,17 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.TextTrackList
-       (js_item, item, item_, itemUnchecked, js_getTrackById,
-        getTrackById, getTrackById_, getTrackByIdUnchecked, js_getLength,
-        getLength, addTrack, change, removeTrack, TextTrackList,
-        castToTextTrackList, gTypeTextTrackList)
+       (js_item, item, item_, itemUnsafe, itemUnchecked, js_getTrackById,
+        getTrackById, getTrackById_, getTrackByIdUnsafe,
+        getTrackByIdUnchecked, js_getLength, getLength, addTrack, change,
+        removeTrack, TextTrackList(..), gTypeTextTrackList)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -21,6 +27,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"item\"]($2)" js_item ::
         TextTrackList -> Word -> IO (Nullable TextTrack)
@@ -35,6 +51,14 @@
 item_ self index = liftIO (void (js_item (self) index))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/TextTrackList.item Mozilla TextTrackList.item documentation> 
+itemUnsafe ::
+           (MonadIO m, HasCallStack) => TextTrackList -> Word -> m TextTrack
+itemUnsafe self index
+  = liftIO
+      ((nullableToMaybe <$> (js_item (self) index)) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/TextTrackList.item Mozilla TextTrackList.item documentation> 
 itemUnchecked ::
               (MonadIO m) => TextTrackList -> Word -> m TextTrack
 itemUnchecked self index
@@ -57,6 +81,15 @@
               (MonadIO m, ToJSString id) => TextTrackList -> id -> m ()
 getTrackById_ self id
   = liftIO (void (js_getTrackById (self) (toJSString id)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/TextTrackList.getTrackById Mozilla TextTrackList.getTrackById documentation> 
+getTrackByIdUnsafe ::
+                   (MonadIO m, ToJSString id, HasCallStack) =>
+                     TextTrackList -> id -> m TextTrack
+getTrackByIdUnsafe self id
+  = liftIO
+      ((nullableToMaybe <$> (js_getTrackById (self) (toJSString id))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/TextTrackList.getTrackById Mozilla TextTrackList.getTrackById documentation> 
 getTrackByIdUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/TimeRanges.hs b/src/GHCJS/DOM/JSFFI/Generated/TimeRanges.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/TimeRanges.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/TimeRanges.hs
@@ -1,9 +1,15 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.TimeRanges
        (js_start, start, start_, js_end, end, end_, js_getLength,
-        getLength, TimeRanges, castToTimeRanges, gTypeTimeRanges)
+        getLength, TimeRanges(..), gTypeTimeRanges)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -19,6 +25,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"start\"]($2)" js_start ::
         TimeRanges -> Word -> IO Double
diff --git a/src/GHCJS/DOM/JSFFI/Generated/Touch.hs b/src/GHCJS/DOM/JSFFI/Generated/Touch.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/Touch.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/Touch.hs
@@ -1,15 +1,21 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.Touch
        (js_getClientX, getClientX, js_getClientY, getClientY,
         js_getScreenX, getScreenX, js_getScreenY, getScreenY, js_getPageX,
         getPageX, js_getPageY, getPageY, js_getTarget, getTarget,
-        getTargetUnchecked, js_getIdentifier, getIdentifier,
-        js_getWebkitRadiusX, getWebkitRadiusX, js_getWebkitRadiusY,
-        getWebkitRadiusY, js_getWebkitRotationAngle,
-        getWebkitRotationAngle, js_getWebkitForce, getWebkitForce, Touch,
-        castToTouch, gTypeTouch)
+        getTargetUnsafe, getTargetUnchecked, js_getIdentifier,
+        getIdentifier, js_getWebkitRadiusX, getWebkitRadiusX,
+        js_getWebkitRadiusY, getWebkitRadiusY, js_getWebkitRotationAngle,
+        getWebkitRotationAngle, js_getWebkitForce, getWebkitForce,
+        Touch(..), gTypeTouch)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -25,6 +31,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"clientX\"]" js_getClientX ::
         Touch -> IO Int
@@ -74,6 +90,14 @@
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Touch.target Mozilla Touch.target documentation> 
 getTarget :: (MonadIO m) => Touch -> m (Maybe EventTarget)
 getTarget self = liftIO (nullableToMaybe <$> (js_getTarget (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Touch.target Mozilla Touch.target documentation> 
+getTargetUnsafe ::
+                (MonadIO m, HasCallStack) => Touch -> m EventTarget
+getTargetUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getTarget (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Touch.target Mozilla Touch.target documentation> 
 getTargetUnchecked :: (MonadIO m) => Touch -> m EventTarget
diff --git a/src/GHCJS/DOM/JSFFI/Generated/TouchEvent.hs b/src/GHCJS/DOM/JSFFI/Generated/TouchEvent.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/TouchEvent.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/TouchEvent.hs
@@ -1,14 +1,20 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.TouchEvent
        (js_initTouchEvent, initTouchEvent, js_getTouches, getTouches,
-        getTouchesUnchecked, js_getTargetTouches, getTargetTouches,
+        getTouchesUnsafe, getTouchesUnchecked, js_getTargetTouches,
+        getTargetTouches, getTargetTouchesUnsafe,
         getTargetTouchesUnchecked, js_getChangedTouches, getChangedTouches,
-        getChangedTouchesUnchecked, js_getCtrlKey, getCtrlKey,
-        js_getShiftKey, getShiftKey, js_getAltKey, getAltKey,
-        js_getMetaKey, getMetaKey, TouchEvent, castToTouchEvent,
-        gTypeTouchEvent)
+        getChangedTouchesUnsafe, getChangedTouchesUnchecked, js_getCtrlKey,
+        getCtrlKey, js_getShiftKey, getShiftKey, js_getAltKey, getAltKey,
+        js_getMetaKey, getMetaKey, TouchEvent(..), gTypeTouchEvent)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -24,6 +30,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe
         "$1[\"initTouchEvent\"]($2, $3, $4,\n$5, $6, $7, $8, $9, $10, $11,\n$12, $13, $14)"
@@ -72,6 +88,14 @@
   = liftIO (nullableToMaybe <$> (js_getTouches (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/TouchEvent.touches Mozilla TouchEvent.touches documentation> 
+getTouchesUnsafe ::
+                 (MonadIO m, HasCallStack) => TouchEvent -> m TouchList
+getTouchesUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getTouches (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/TouchEvent.touches Mozilla TouchEvent.touches documentation> 
 getTouchesUnchecked :: (MonadIO m) => TouchEvent -> m TouchList
 getTouchesUnchecked self
   = liftIO (fromJust . nullableToMaybe <$> (js_getTouches (self)))
@@ -86,6 +110,14 @@
   = liftIO (nullableToMaybe <$> (js_getTargetTouches (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/TouchEvent.targetTouches Mozilla TouchEvent.targetTouches documentation> 
+getTargetTouchesUnsafe ::
+                       (MonadIO m, HasCallStack) => TouchEvent -> m TouchList
+getTargetTouchesUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getTargetTouches (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/TouchEvent.targetTouches Mozilla TouchEvent.targetTouches documentation> 
 getTargetTouchesUnchecked ::
                           (MonadIO m) => TouchEvent -> m TouchList
 getTargetTouchesUnchecked self
@@ -100,6 +132,14 @@
                   (MonadIO m) => TouchEvent -> m (Maybe TouchList)
 getChangedTouches self
   = liftIO (nullableToMaybe <$> (js_getChangedTouches (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/TouchEvent.changedTouches Mozilla TouchEvent.changedTouches documentation> 
+getChangedTouchesUnsafe ::
+                        (MonadIO m, HasCallStack) => TouchEvent -> m TouchList
+getChangedTouchesUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getChangedTouches (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/TouchEvent.changedTouches Mozilla TouchEvent.changedTouches documentation> 
 getChangedTouchesUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/TouchList.hs b/src/GHCJS/DOM/JSFFI/Generated/TouchList.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/TouchList.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/TouchList.hs
@@ -1,9 +1,15 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.TouchList
-       (js_item, item, item_, itemUnchecked, js_getLength, getLength,
-        TouchList, castToTouchList, gTypeTouchList)
+       (js_item, item, item_, itemUnsafe, itemUnchecked, js_getLength,
+        getLength, TouchList(..), gTypeTouchList)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -19,6 +25,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"item\"]($2)" js_item ::
         TouchList -> Word -> IO (Nullable Touch)
@@ -31,6 +47,14 @@
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/TouchList.item Mozilla TouchList.item documentation> 
 item_ :: (MonadIO m) => TouchList -> Word -> m ()
 item_ self index = liftIO (void (js_item (self) index))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/TouchList.item Mozilla TouchList.item documentation> 
+itemUnsafe ::
+           (MonadIO m, HasCallStack) => TouchList -> Word -> m Touch
+itemUnsafe self index
+  = liftIO
+      ((nullableToMaybe <$> (js_item (self) index)) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/TouchList.item Mozilla TouchList.item documentation> 
 itemUnchecked :: (MonadIO m) => TouchList -> Word -> m Touch
diff --git a/src/GHCJS/DOM/JSFFI/Generated/TrackEvent.hs b/src/GHCJS/DOM/JSFFI/Generated/TrackEvent.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/TrackEvent.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/TrackEvent.hs
@@ -1,9 +1,15 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.TrackEvent
-       (js_getTrack, getTrack, getTrackUnchecked, TrackEvent,
-        castToTrackEvent, gTypeTrackEvent)
+       (js_getTrack, getTrack, getTrackUnsafe, getTrackUnchecked,
+        TrackEvent(..), gTypeTrackEvent)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -19,6 +25,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"track\"]" js_getTrack ::
         TrackEvent -> IO (Nullable GObject)
@@ -26,6 +42,14 @@
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/TrackEvent.track Mozilla TrackEvent.track documentation> 
 getTrack :: (MonadIO m) => TrackEvent -> m (Maybe GObject)
 getTrack self = liftIO (nullableToMaybe <$> (js_getTrack (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/TrackEvent.track Mozilla TrackEvent.track documentation> 
+getTrackUnsafe ::
+               (MonadIO m, HasCallStack) => TrackEvent -> m GObject
+getTrackUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getTrack (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/TrackEvent.track Mozilla TrackEvent.track documentation> 
 getTrackUnchecked :: (MonadIO m) => TrackEvent -> m GObject
diff --git a/src/GHCJS/DOM/JSFFI/Generated/TransitionEvent.hs b/src/GHCJS/DOM/JSFFI/Generated/TransitionEvent.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/TransitionEvent.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/TransitionEvent.hs
@@ -1,10 +1,16 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.TransitionEvent
        (js_getPropertyName, getPropertyName, js_getElapsedTime,
         getElapsedTime, js_getPseudoElement, getPseudoElement,
-        TransitionEvent, castToTransitionEvent, gTypeTransitionEvent)
+        TransitionEvent(..), gTypeTransitionEvent)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -20,6 +26,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"propertyName\"]"
         js_getPropertyName :: TransitionEvent -> IO JSString
diff --git a/src/GHCJS/DOM/JSFFI/Generated/TreeWalker.hs b/src/GHCJS/DOM/JSFFI/Generated/TreeWalker.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/TreeWalker.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/TreeWalker.hs
@@ -1,20 +1,29 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.TreeWalker
-       (js_parentNode, parentNode, parentNode_, parentNodeUnchecked,
-        js_firstChild, firstChild, firstChild_, firstChildUnchecked,
-        js_lastChild, lastChild, lastChild_, lastChildUnchecked,
+       (js_parentNode, parentNode, parentNode_, parentNodeUnsafe,
+        parentNodeUnchecked, js_firstChild, firstChild, firstChild_,
+        firstChildUnsafe, firstChildUnchecked, js_lastChild, lastChild,
+        lastChild_, lastChildUnsafe, lastChildUnchecked,
         js_previousSibling, previousSibling, previousSibling_,
-        previousSiblingUnchecked, js_nextSibling, nextSibling,
-        nextSibling_, nextSiblingUnchecked, js_previousNode, previousNode,
-        previousNode_, previousNodeUnchecked, js_nextNode, nextNode,
-        nextNode_, nextNodeUnchecked, js_getRoot, getRoot,
-        getRootUnchecked, js_getWhatToShow, getWhatToShow, js_getFilter,
-        getFilter, getFilterUnchecked, js_getExpandEntityReferences,
-        getExpandEntityReferences, js_setCurrentNode, setCurrentNode,
-        js_getCurrentNode, getCurrentNode, getCurrentNodeUnchecked,
-        TreeWalker, castToTreeWalker, gTypeTreeWalker)
+        previousSiblingUnsafe, previousSiblingUnchecked, js_nextSibling,
+        nextSibling, nextSibling_, nextSiblingUnsafe, nextSiblingUnchecked,
+        js_previousNode, previousNode, previousNode_, previousNodeUnsafe,
+        previousNodeUnchecked, js_nextNode, nextNode, nextNode_,
+        nextNodeUnsafe, nextNodeUnchecked, js_getRoot, getRoot,
+        getRootUnsafe, getRootUnchecked, js_getWhatToShow, getWhatToShow,
+        js_getFilter, getFilter, getFilterUnsafe, getFilterUnchecked,
+        js_getExpandEntityReferences, getExpandEntityReferences,
+        js_setCurrentNode, setCurrentNode, js_getCurrentNode,
+        getCurrentNode, getCurrentNodeUnsafe, getCurrentNodeUnchecked,
+        TreeWalker(..), gTypeTreeWalker)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -30,6 +39,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"parentNode\"]()"
         js_parentNode :: TreeWalker -> IO (Nullable Node)
@@ -44,6 +63,14 @@
 parentNode_ self = liftIO (void (js_parentNode (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/TreeWalker.parentNode Mozilla TreeWalker.parentNode documentation> 
+parentNodeUnsafe ::
+                 (MonadIO m, HasCallStack) => TreeWalker -> m Node
+parentNodeUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_parentNode (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/TreeWalker.parentNode Mozilla TreeWalker.parentNode documentation> 
 parentNodeUnchecked :: (MonadIO m) => TreeWalker -> m Node
 parentNodeUnchecked self
   = liftIO (fromJust . nullableToMaybe <$> (js_parentNode (self)))
@@ -61,6 +88,14 @@
 firstChild_ self = liftIO (void (js_firstChild (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/TreeWalker.firstChild Mozilla TreeWalker.firstChild documentation> 
+firstChildUnsafe ::
+                 (MonadIO m, HasCallStack) => TreeWalker -> m Node
+firstChildUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_firstChild (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/TreeWalker.firstChild Mozilla TreeWalker.firstChild documentation> 
 firstChildUnchecked :: (MonadIO m) => TreeWalker -> m Node
 firstChildUnchecked self
   = liftIO (fromJust . nullableToMaybe <$> (js_firstChild (self)))
@@ -77,6 +112,14 @@
 lastChild_ self = liftIO (void (js_lastChild (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/TreeWalker.lastChild Mozilla TreeWalker.lastChild documentation> 
+lastChildUnsafe ::
+                (MonadIO m, HasCallStack) => TreeWalker -> m Node
+lastChildUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_lastChild (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/TreeWalker.lastChild Mozilla TreeWalker.lastChild documentation> 
 lastChildUnchecked :: (MonadIO m) => TreeWalker -> m Node
 lastChildUnchecked self
   = liftIO (fromJust . nullableToMaybe <$> (js_lastChild (self)))
@@ -94,6 +137,14 @@
 previousSibling_ self = liftIO (void (js_previousSibling (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/TreeWalker.previousSibling Mozilla TreeWalker.previousSibling documentation> 
+previousSiblingUnsafe ::
+                      (MonadIO m, HasCallStack) => TreeWalker -> m Node
+previousSiblingUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_previousSibling (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/TreeWalker.previousSibling Mozilla TreeWalker.previousSibling documentation> 
 previousSiblingUnchecked :: (MonadIO m) => TreeWalker -> m Node
 previousSiblingUnchecked self
   = liftIO
@@ -112,6 +163,14 @@
 nextSibling_ self = liftIO (void (js_nextSibling (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/TreeWalker.nextSibling Mozilla TreeWalker.nextSibling documentation> 
+nextSiblingUnsafe ::
+                  (MonadIO m, HasCallStack) => TreeWalker -> m Node
+nextSiblingUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_nextSibling (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/TreeWalker.nextSibling Mozilla TreeWalker.nextSibling documentation> 
 nextSiblingUnchecked :: (MonadIO m) => TreeWalker -> m Node
 nextSiblingUnchecked self
   = liftIO (fromJust . nullableToMaybe <$> (js_nextSibling (self)))
@@ -129,6 +188,14 @@
 previousNode_ self = liftIO (void (js_previousNode (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/TreeWalker.previousNode Mozilla TreeWalker.previousNode documentation> 
+previousNodeUnsafe ::
+                   (MonadIO m, HasCallStack) => TreeWalker -> m Node
+previousNodeUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_previousNode (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/TreeWalker.previousNode Mozilla TreeWalker.previousNode documentation> 
 previousNodeUnchecked :: (MonadIO m) => TreeWalker -> m Node
 previousNodeUnchecked self
   = liftIO (fromJust . nullableToMaybe <$> (js_previousNode (self)))
@@ -145,6 +212,13 @@
 nextNode_ self = liftIO (void (js_nextNode (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/TreeWalker.nextNode Mozilla TreeWalker.nextNode documentation> 
+nextNodeUnsafe :: (MonadIO m, HasCallStack) => TreeWalker -> m Node
+nextNodeUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_nextNode (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/TreeWalker.nextNode Mozilla TreeWalker.nextNode documentation> 
 nextNodeUnchecked :: (MonadIO m) => TreeWalker -> m Node
 nextNodeUnchecked self
   = liftIO (fromJust . nullableToMaybe <$> (js_nextNode (self)))
@@ -157,6 +231,13 @@
 getRoot self = liftIO (nullableToMaybe <$> (js_getRoot (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/TreeWalker.root Mozilla TreeWalker.root documentation> 
+getRootUnsafe :: (MonadIO m, HasCallStack) => TreeWalker -> m Node
+getRootUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getRoot (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/TreeWalker.root Mozilla TreeWalker.root documentation> 
 getRootUnchecked :: (MonadIO m) => TreeWalker -> m Node
 getRootUnchecked self
   = liftIO (fromJust . nullableToMaybe <$> (js_getRoot (self)))
@@ -176,6 +257,14 @@
 getFilter self = liftIO (nullableToMaybe <$> (js_getFilter (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/TreeWalker.filter Mozilla TreeWalker.filter documentation> 
+getFilterUnsafe ::
+                (MonadIO m, HasCallStack) => TreeWalker -> m NodeFilter
+getFilterUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getFilter (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/TreeWalker.filter Mozilla TreeWalker.filter documentation> 
 getFilterUnchecked :: (MonadIO m) => TreeWalker -> m NodeFilter
 getFilterUnchecked self
   = liftIO (fromJust . nullableToMaybe <$> (js_getFilter (self)))
@@ -206,6 +295,14 @@
 getCurrentNode :: (MonadIO m) => TreeWalker -> m (Maybe Node)
 getCurrentNode self
   = liftIO (nullableToMaybe <$> (js_getCurrentNode (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/TreeWalker.currentNode Mozilla TreeWalker.currentNode documentation> 
+getCurrentNodeUnsafe ::
+                     (MonadIO m, HasCallStack) => TreeWalker -> m Node
+getCurrentNodeUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getCurrentNode (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/TreeWalker.currentNode Mozilla TreeWalker.currentNode documentation> 
 getCurrentNodeUnchecked :: (MonadIO m) => TreeWalker -> m Node
diff --git a/src/GHCJS/DOM/JSFFI/Generated/TypeConversions.hs b/src/GHCJS/DOM/JSFFI/Generated/TypeConversions.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/TypeConversions.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/TypeConversions.hs
@@ -1,4 +1,9 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.TypeConversions
        (js_setTestLong, setTestLong, js_getTestLong, getTestLong,
         js_setTestEnforceRangeLong, setTestEnforceRangeLong,
@@ -31,10 +36,11 @@
         getTestUnsignedShort, js_setTestEnforceRangeUnsignedShort,
         setTestEnforceRangeUnsignedShort,
         js_getTestEnforceRangeUnsignedShort,
-        getTestEnforceRangeUnsignedShort, TypeConversions,
-        castToTypeConversions, gTypeTypeConversions)
+        getTestEnforceRangeUnsignedShort, TypeConversions(..),
+        gTypeTypeConversions)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -50,6 +56,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"testLong\"] = $2;"
         js_setTestLong :: TypeConversions -> Int -> IO ()
diff --git a/src/GHCJS/DOM/JSFFI/Generated/UIEvent.hs b/src/GHCJS/DOM/JSFFI/Generated/UIEvent.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/UIEvent.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/UIEvent.hs
@@ -1,13 +1,19 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.UIEvent
-       (js_initUIEvent, initUIEvent, js_getView, getView,
+       (js_initUIEvent, initUIEvent, js_getView, getView, getViewUnsafe,
         getViewUnchecked, js_getDetail, getDetail, js_getKeyCode,
         getKeyCode, js_getCharCode, getCharCode, js_getLayerX, getLayerX,
         js_getLayerY, getLayerY, js_getPageX, getPageX, js_getPageY,
-        getPageY, js_getWhich, getWhich, UIEvent, castToUIEvent,
-        gTypeUIEvent, IsUIEvent, toUIEvent)
+        getPageY, js_getWhich, getWhich, UIEvent(..), gTypeUIEvent,
+        IsUIEvent, toUIEvent)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -22,6 +28,16 @@
 import GHCJS.DOM.Types
 import Control.Applicative ((<$>))
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe
         "$1[\"initUIEvent\"]($2, $3, $4,\n$5, $6)" js_initUIEvent ::
@@ -46,6 +62,14 @@
 getView :: (MonadIO m, IsUIEvent self) => self -> m (Maybe Window)
 getView self
   = liftIO (nullableToMaybe <$> (js_getView (toUIEvent self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/UIEvent.view Mozilla UIEvent.view documentation> 
+getViewUnsafe ::
+              (MonadIO m, IsUIEvent self, HasCallStack) => self -> m Window
+getViewUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getView (toUIEvent self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/UIEvent.view Mozilla UIEvent.view documentation> 
 getViewUnchecked :: (MonadIO m, IsUIEvent self) => self -> m Window
diff --git a/src/GHCJS/DOM/JSFFI/Generated/UIRequestEvent.hs b/src/GHCJS/DOM/JSFFI/Generated/UIRequestEvent.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/UIRequestEvent.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/UIRequestEvent.hs
@@ -1,9 +1,15 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.UIRequestEvent
-       (js_getReceiver, getReceiver, getReceiverUnchecked, UIRequestEvent,
-        castToUIRequestEvent, gTypeUIRequestEvent)
+       (js_getReceiver, getReceiver, getReceiverUnsafe,
+        getReceiverUnchecked, UIRequestEvent(..), gTypeUIRequestEvent)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -19,6 +25,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"receiver\"]" js_getReceiver
         :: UIRequestEvent -> IO (Nullable EventTarget)
@@ -28,6 +44,14 @@
             (MonadIO m) => UIRequestEvent -> m (Maybe EventTarget)
 getReceiver self
   = liftIO (nullableToMaybe <$> (js_getReceiver (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/UIRequestEvent.receiver Mozilla UIRequestEvent.receiver documentation> 
+getReceiverUnsafe ::
+                  (MonadIO m, HasCallStack) => UIRequestEvent -> m EventTarget
+getReceiverUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getReceiver (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/UIRequestEvent.receiver Mozilla UIRequestEvent.receiver documentation> 
 getReceiverUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/URL.hs b/src/GHCJS/DOM/JSFFI/Generated/URL.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/URL.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/URL.hs
@@ -1,15 +1,22 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.URL
        (js_newURL, newURL, js_newURL', newURL', js_newURL'', newURL'',
         js_createObjectURL, createObjectURL, createObjectURL_,
-        createObjectURLUnchecked, js_revokeObjectURL, revokeObjectURL,
-        js_createObjectURLSource, createObjectURLSource,
-        createObjectURLSource_, createObjectURLSourceUnchecked,
+        createObjectURLUnsafe, createObjectURLUnchecked,
+        js_revokeObjectURL, revokeObjectURL, js_createObjectURLSource,
+        createObjectURLSource, createObjectURLSource_,
+        createObjectURLSourceUnsafe, createObjectURLSourceUnchecked,
         js_createObjectURLStream, createObjectURLStream,
-        createObjectURLStream_, createObjectURLStreamUnchecked, URL,
-        castToURL, gTypeURL)
+        createObjectURLStream_, createObjectURLStreamUnsafe,
+        createObjectURLStreamUnchecked, URL(..), gTypeURL)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -25,6 +32,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "new window[\"URL\"]($1)"
         js_newURL :: JSString -> IO URL
@@ -74,6 +91,16 @@
          (js_createObjectURL (self) (maybeToNullable (fmap toBlob blob))))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/URL.createObjectURL Mozilla URL.createObjectURL documentation> 
+createObjectURLUnsafe ::
+                      (MonadIO m, IsBlob blob, HasCallStack, FromJSString result) =>
+                        URL -> Maybe blob -> m result
+createObjectURLUnsafe self blob
+  = liftIO
+      ((fromMaybeJSString <$>
+          (js_createObjectURL (self) (maybeToNullable (fmap toBlob blob))))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/URL.createObjectURL Mozilla URL.createObjectURL documentation> 
 createObjectURLUnchecked ::
                          (MonadIO m, IsBlob blob, FromJSString result) =>
                            URL -> Maybe blob -> m result
@@ -112,6 +139,16 @@
       (void (js_createObjectURLSource (self) (maybeToNullable source)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/URL.createObjectURL Mozilla URL.createObjectURL documentation> 
+createObjectURLSourceUnsafe ::
+                            (MonadIO m, HasCallStack, FromJSString result) =>
+                              URL -> Maybe MediaSource -> m result
+createObjectURLSourceUnsafe self source
+  = liftIO
+      ((fromMaybeJSString <$>
+          (js_createObjectURLSource (self) (maybeToNullable source)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/URL.createObjectURL Mozilla URL.createObjectURL documentation> 
 createObjectURLSourceUnchecked ::
                                (MonadIO m, FromJSString result) =>
                                  URL -> Maybe MediaSource -> m result
@@ -139,6 +176,16 @@
 createObjectURLStream_ self stream
   = liftIO
       (void (js_createObjectURLStream (self) (maybeToNullable stream)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/URL.createObjectURL Mozilla URL.createObjectURL documentation> 
+createObjectURLStreamUnsafe ::
+                            (MonadIO m, HasCallStack, FromJSString result) =>
+                              URL -> Maybe MediaStream -> m result
+createObjectURLStreamUnsafe self stream
+  = liftIO
+      ((fromMaybeJSString <$>
+          (js_createObjectURLStream (self) (maybeToNullable stream)))
+         >>= maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/URL.createObjectURL Mozilla URL.createObjectURL documentation> 
 createObjectURLStreamUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/URLUtils.hs b/src/GHCJS/DOM/JSFFI/Generated/URLUtils.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/URLUtils.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/URLUtils.hs
@@ -1,20 +1,29 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.URLUtils
        (js_toString, toString, toString_, js_setHref, setHref, js_getHref,
         getHref, js_getOrigin, getOrigin, js_setProtocol, setProtocol,
-        js_getProtocol, getProtocol, getProtocolUnchecked, js_setUsername,
-        setUsername, js_getUsername, getUsername, getUsernameUnchecked,
+        js_getProtocol, getProtocol, getProtocolUnsafe,
+        getProtocolUnchecked, js_setUsername, setUsername, js_getUsername,
+        getUsername, getUsernameUnsafe, getUsernameUnchecked,
         js_setPassword, setPassword, js_getPassword, getPassword,
-        getPasswordUnchecked, js_setHost, setHost, js_getHost, getHost,
-        getHostUnchecked, js_setHostname, setHostname, js_getHostname,
-        getHostname, getHostnameUnchecked, js_setPort, setPort, js_getPort,
-        getPort, getPortUnchecked, js_setPathname, setPathname,
-        js_getPathname, getPathname, getPathnameUnchecked, js_setSearch,
-        setSearch, js_getSearch, getSearch, getSearchUnchecked, js_setHash,
-        setHash, js_getHash, getHash, getHashUnchecked, URLUtils,
-        castToURLUtils, gTypeURLUtils)
+        getPasswordUnsafe, getPasswordUnchecked, js_setHost, setHost,
+        js_getHost, getHost, getHostUnsafe, getHostUnchecked,
+        js_setHostname, setHostname, js_getHostname, getHostname,
+        getHostnameUnsafe, getHostnameUnchecked, js_setPort, setPort,
+        js_getPort, getPort, getPortUnsafe, getPortUnchecked,
+        js_setPathname, setPathname, js_getPathname, getPathname,
+        getPathnameUnsafe, getPathnameUnchecked, js_setSearch, setSearch,
+        js_getSearch, getSearch, getSearchUnsafe, getSearchUnchecked,
+        js_setHash, setHash, js_getHash, getHash, getHashUnsafe,
+        getHashUnchecked, URLUtils(..), gTypeURLUtils)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -30,6 +39,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"toString\"]()" js_toString
         :: URLUtils -> IO JSString
@@ -84,6 +103,15 @@
   = liftIO (fromMaybeJSString <$> (js_getProtocol (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/URLUtils.protocol Mozilla URLUtils.protocol documentation> 
+getProtocolUnsafe ::
+                  (MonadIO m, HasCallStack, FromJSString result) =>
+                    URLUtils -> m result
+getProtocolUnsafe self
+  = liftIO
+      ((fromMaybeJSString <$> (js_getProtocol (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/URLUtils.protocol Mozilla URLUtils.protocol documentation> 
 getProtocolUnchecked ::
                      (MonadIO m, FromJSString result) => URLUtils -> m result
 getProtocolUnchecked self
@@ -108,6 +136,15 @@
   = liftIO (fromMaybeJSString <$> (js_getUsername (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/URLUtils.username Mozilla URLUtils.username documentation> 
+getUsernameUnsafe ::
+                  (MonadIO m, HasCallStack, FromJSString result) =>
+                    URLUtils -> m result
+getUsernameUnsafe self
+  = liftIO
+      ((fromMaybeJSString <$> (js_getUsername (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/URLUtils.username Mozilla URLUtils.username documentation> 
 getUsernameUnchecked ::
                      (MonadIO m, FromJSString result) => URLUtils -> m result
 getUsernameUnchecked self
@@ -132,6 +169,15 @@
   = liftIO (fromMaybeJSString <$> (js_getPassword (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/URLUtils.password Mozilla URLUtils.password documentation> 
+getPasswordUnsafe ::
+                  (MonadIO m, HasCallStack, FromJSString result) =>
+                    URLUtils -> m result
+getPasswordUnsafe self
+  = liftIO
+      ((fromMaybeJSString <$> (js_getPassword (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/URLUtils.password Mozilla URLUtils.password documentation> 
 getPasswordUnchecked ::
                      (MonadIO m, FromJSString result) => URLUtils -> m result
 getPasswordUnchecked self
@@ -154,6 +200,15 @@
 getHost self = liftIO (fromMaybeJSString <$> (js_getHost (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/URLUtils.host Mozilla URLUtils.host documentation> 
+getHostUnsafe ::
+              (MonadIO m, HasCallStack, FromJSString result) =>
+                URLUtils -> m result
+getHostUnsafe self
+  = liftIO
+      ((fromMaybeJSString <$> (js_getHost (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/URLUtils.host Mozilla URLUtils.host documentation> 
 getHostUnchecked ::
                  (MonadIO m, FromJSString result) => URLUtils -> m result
 getHostUnchecked self
@@ -178,6 +233,15 @@
   = liftIO (fromMaybeJSString <$> (js_getHostname (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/URLUtils.hostname Mozilla URLUtils.hostname documentation> 
+getHostnameUnsafe ::
+                  (MonadIO m, HasCallStack, FromJSString result) =>
+                    URLUtils -> m result
+getHostnameUnsafe self
+  = liftIO
+      ((fromMaybeJSString <$> (js_getHostname (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/URLUtils.hostname Mozilla URLUtils.hostname documentation> 
 getHostnameUnchecked ::
                      (MonadIO m, FromJSString result) => URLUtils -> m result
 getHostnameUnchecked self
@@ -200,6 +264,15 @@
 getPort self = liftIO (fromMaybeJSString <$> (js_getPort (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/URLUtils.port Mozilla URLUtils.port documentation> 
+getPortUnsafe ::
+              (MonadIO m, HasCallStack, FromJSString result) =>
+                URLUtils -> m result
+getPortUnsafe self
+  = liftIO
+      ((fromMaybeJSString <$> (js_getPort (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/URLUtils.port Mozilla URLUtils.port documentation> 
 getPortUnchecked ::
                  (MonadIO m, FromJSString result) => URLUtils -> m result
 getPortUnchecked self
@@ -224,6 +297,15 @@
   = liftIO (fromMaybeJSString <$> (js_getPathname (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/URLUtils.pathname Mozilla URLUtils.pathname documentation> 
+getPathnameUnsafe ::
+                  (MonadIO m, HasCallStack, FromJSString result) =>
+                    URLUtils -> m result
+getPathnameUnsafe self
+  = liftIO
+      ((fromMaybeJSString <$> (js_getPathname (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/URLUtils.pathname Mozilla URLUtils.pathname documentation> 
 getPathnameUnchecked ::
                      (MonadIO m, FromJSString result) => URLUtils -> m result
 getPathnameUnchecked self
@@ -248,6 +330,15 @@
   = liftIO (fromMaybeJSString <$> (js_getSearch (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/URLUtils.search Mozilla URLUtils.search documentation> 
+getSearchUnsafe ::
+                (MonadIO m, HasCallStack, FromJSString result) =>
+                  URLUtils -> m result
+getSearchUnsafe self
+  = liftIO
+      ((fromMaybeJSString <$> (js_getSearch (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/URLUtils.search Mozilla URLUtils.search documentation> 
 getSearchUnchecked ::
                    (MonadIO m, FromJSString result) => URLUtils -> m result
 getSearchUnchecked self
@@ -268,6 +359,15 @@
 getHash ::
         (MonadIO m, FromJSString result) => URLUtils -> m (Maybe result)
 getHash self = liftIO (fromMaybeJSString <$> (js_getHash (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/URLUtils.hash Mozilla URLUtils.hash documentation> 
+getHashUnsafe ::
+              (MonadIO m, HasCallStack, FromJSString result) =>
+                URLUtils -> m result
+getHashUnsafe self
+  = liftIO
+      ((fromMaybeJSString <$> (js_getHash (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/URLUtils.hash Mozilla URLUtils.hash documentation> 
 getHashUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/UserMessageHandler.hs b/src/GHCJS/DOM/JSFFI/Generated/UserMessageHandler.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/UserMessageHandler.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/UserMessageHandler.hs
@@ -1,9 +1,15 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.UserMessageHandler
-       (js_postMessage, postMessage, UserMessageHandler,
-        castToUserMessageHandler, gTypeUserMessageHandler)
+       (js_postMessage, postMessage, UserMessageHandler(..),
+        gTypeUserMessageHandler)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -19,6 +25,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"postMessage\"]($2)"
         js_postMessage ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/VTTCue.hs b/src/GHCJS/DOM/JSFFI/Generated/VTTCue.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/VTTCue.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/VTTCue.hs
@@ -1,16 +1,23 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.VTTCue
        (js_newVTTCue, newVTTCue, js_getCueAsHTML, getCueAsHTML,
-        getCueAsHTML_, getCueAsHTMLUnchecked, js_setVertical, setVertical,
-        js_getVertical, getVertical, js_setSnapToLines, setSnapToLines,
-        js_getSnapToLines, getSnapToLines, js_setLine, setLine, js_getLine,
-        getLine, js_setPosition, setPosition, js_getPosition, getPosition,
+        getCueAsHTML_, getCueAsHTMLUnsafe, getCueAsHTMLUnchecked,
+        js_setVertical, setVertical, js_getVertical, getVertical,
+        js_setSnapToLines, setSnapToLines, js_getSnapToLines,
+        getSnapToLines, js_setLine, setLine, js_getLine, getLine,
+        js_setPosition, setPosition, js_getPosition, getPosition,
         js_setSize, setSize, js_getSize, getSize, js_setAlign, setAlign,
         js_getAlign, getAlign, js_setText, setText, js_getText, getText,
-        js_setRegionId, setRegionId, js_getRegionId, getRegionId, VTTCue,
-        castToVTTCue, gTypeVTTCue)
+        js_setRegionId, setRegionId, js_getRegionId, getRegionId,
+        VTTCue(..), gTypeVTTCue)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -26,6 +33,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe
         "new window[\"VTTCue\"]($1, $2, $3)" js_newVTTCue ::
@@ -49,6 +66,14 @@
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/VTTCue.getCueAsHTML Mozilla VTTCue.getCueAsHTML documentation> 
 getCueAsHTML_ :: (MonadIO m) => VTTCue -> m ()
 getCueAsHTML_ self = liftIO (void (js_getCueAsHTML (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/VTTCue.getCueAsHTML Mozilla VTTCue.getCueAsHTML documentation> 
+getCueAsHTMLUnsafe ::
+                   (MonadIO m, HasCallStack) => VTTCue -> m DocumentFragment
+getCueAsHTMLUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getCueAsHTML (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/VTTCue.getCueAsHTML Mozilla VTTCue.getCueAsHTML documentation> 
 getCueAsHTMLUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/VTTRegion.hs b/src/GHCJS/DOM/JSFFI/Generated/VTTRegion.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/VTTRegion.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/VTTRegion.hs
@@ -1,18 +1,24 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.VTTRegion
        (js_newVTTRegion, newVTTRegion, js_getTrack, getTrack,
-        getTrackUnchecked, js_setId, setId, js_getId, getId, js_setWidth,
-        setWidth, js_getWidth, getWidth, js_setHeight, setHeight,
-        js_getHeight, getHeight, js_setRegionAnchorX, setRegionAnchorX,
-        js_getRegionAnchorX, getRegionAnchorX, js_setRegionAnchorY,
-        setRegionAnchorY, js_getRegionAnchorY, getRegionAnchorY,
-        js_setViewportAnchorX, setViewportAnchorX, js_getViewportAnchorX,
-        getViewportAnchorX, js_setViewportAnchorY, setViewportAnchorY,
-        js_getViewportAnchorY, getViewportAnchorY, js_setScroll, setScroll,
-        js_getScroll, getScroll, VTTRegion, castToVTTRegion,
+        getTrackUnsafe, getTrackUnchecked, js_setId, setId, js_getId,
+        getId, js_setWidth, setWidth, js_getWidth, getWidth, js_setHeight,
+        setHeight, js_getHeight, getHeight, js_setRegionAnchorX,
+        setRegionAnchorX, js_getRegionAnchorX, getRegionAnchorX,
+        js_setRegionAnchorY, setRegionAnchorY, js_getRegionAnchorY,
+        getRegionAnchorY, js_setViewportAnchorX, setViewportAnchorX,
+        js_getViewportAnchorX, getViewportAnchorX, js_setViewportAnchorY,
+        setViewportAnchorY, js_getViewportAnchorY, getViewportAnchorY,
+        js_setScroll, setScroll, js_getScroll, getScroll, VTTRegion(..),
         gTypeVTTRegion)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -28,6 +34,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "new window[\"VTTRegion\"]()"
         js_newVTTRegion :: IO VTTRegion
@@ -42,6 +58,14 @@
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/VTTRegion.track Mozilla VTTRegion.track documentation> 
 getTrack :: (MonadIO m) => VTTRegion -> m (Maybe TextTrack)
 getTrack self = liftIO (nullableToMaybe <$> (js_getTrack (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/VTTRegion.track Mozilla VTTRegion.track documentation> 
+getTrackUnsafe ::
+               (MonadIO m, HasCallStack) => VTTRegion -> m TextTrack
+getTrackUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getTrack (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/VTTRegion.track Mozilla VTTRegion.track documentation> 
 getTrackUnchecked :: (MonadIO m) => VTTRegion -> m TextTrack
diff --git a/src/GHCJS/DOM/JSFFI/Generated/VTTRegionList.hs b/src/GHCJS/DOM/JSFFI/Generated/VTTRegionList.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/VTTRegionList.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/VTTRegionList.hs
@@ -1,11 +1,17 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.VTTRegionList
-       (js_item, item, item_, itemUnchecked, js_getRegionById,
-        getRegionById, getRegionById_, getRegionByIdUnchecked,
-        js_getLength, getLength, VTTRegionList, castToVTTRegionList,
+       (js_item, item, item_, itemUnsafe, itemUnchecked, js_getRegionById,
+        getRegionById, getRegionById_, getRegionByIdUnsafe,
+        getRegionByIdUnchecked, js_getLength, getLength, VTTRegionList(..),
         gTypeVTTRegionList)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -21,6 +27,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"item\"]($2)" js_item ::
         VTTRegionList -> Word -> IO (Nullable VTTRegion)
@@ -35,6 +51,14 @@
 item_ self index = liftIO (void (js_item (self) index))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/VTTRegionList.item Mozilla VTTRegionList.item documentation> 
+itemUnsafe ::
+           (MonadIO m, HasCallStack) => VTTRegionList -> Word -> m VTTRegion
+itemUnsafe self index
+  = liftIO
+      ((nullableToMaybe <$> (js_item (self) index)) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/VTTRegionList.item Mozilla VTTRegionList.item documentation> 
 itemUnchecked ::
               (MonadIO m) => VTTRegionList -> Word -> m VTTRegion
 itemUnchecked self index
@@ -57,6 +81,15 @@
                (MonadIO m, ToJSString id) => VTTRegionList -> id -> m ()
 getRegionById_ self id
   = liftIO (void (js_getRegionById (self) (toJSString id)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/VTTRegionList.getRegionById Mozilla VTTRegionList.getRegionById documentation> 
+getRegionByIdUnsafe ::
+                    (MonadIO m, ToJSString id, HasCallStack) =>
+                      VTTRegionList -> id -> m VTTRegion
+getRegionByIdUnsafe self id
+  = liftIO
+      ((nullableToMaybe <$> (js_getRegionById (self) (toJSString id)))
+         >>= maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/VTTRegionList.getRegionById Mozilla VTTRegionList.getRegionById documentation> 
 getRegionByIdUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/ValidityState.hs b/src/GHCJS/DOM/JSFFI/Generated/ValidityState.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/ValidityState.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/ValidityState.hs
@@ -1,14 +1,20 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.ValidityState
        (js_getValueMissing, getValueMissing, js_getTypeMismatch,
         getTypeMismatch, js_getPatternMismatch, getPatternMismatch,
         js_getTooLong, getTooLong, js_getRangeUnderflow, getRangeUnderflow,
         js_getRangeOverflow, getRangeOverflow, js_getStepMismatch,
         getStepMismatch, js_getBadInput, getBadInput, js_getCustomError,
-        getCustomError, js_getValid, getValid, ValidityState,
-        castToValidityState, gTypeValidityState)
+        getCustomError, js_getValid, getValid, ValidityState(..),
+        gTypeValidityState)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -24,6 +30,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "($1[\"valueMissing\"] ? 1 : 0)"
         js_getValueMissing :: ValidityState -> IO Bool
diff --git a/src/GHCJS/DOM/JSFFI/Generated/VideoPlaybackQuality.hs b/src/GHCJS/DOM/JSFFI/Generated/VideoPlaybackQuality.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/VideoPlaybackQuality.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/VideoPlaybackQuality.hs
@@ -1,13 +1,18 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.VideoPlaybackQuality
        (js_getCreationTime, getCreationTime, js_getTotalVideoFrames,
         getTotalVideoFrames, js_getDroppedVideoFrames,
         getDroppedVideoFrames, js_getCorruptedVideoFrames,
         getCorruptedVideoFrames, js_getTotalFrameDelay, getTotalFrameDelay,
-        VideoPlaybackQuality, castToVideoPlaybackQuality,
-        gTypeVideoPlaybackQuality)
+        VideoPlaybackQuality(..), gTypeVideoPlaybackQuality)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -23,6 +28,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"creationTime\"]"
         js_getCreationTime :: VideoPlaybackQuality -> IO Double
diff --git a/src/GHCJS/DOM/JSFFI/Generated/VideoStreamTrack.hs b/src/GHCJS/DOM/JSFFI/Generated/VideoStreamTrack.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/VideoStreamTrack.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/VideoStreamTrack.hs
@@ -1,9 +1,15 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.VideoStreamTrack
-       (js_newVideoStreamTrack, newVideoStreamTrack, VideoStreamTrack,
-        castToVideoStreamTrack, gTypeVideoStreamTrack)
+       (js_newVideoStreamTrack, newVideoStreamTrack, VideoStreamTrack(..),
+        gTypeVideoStreamTrack)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -19,6 +25,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe
         "new window[\"VideoStreamTrack\"]($1)" js_newVideoStreamTrack ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/VideoTrack.hs b/src/GHCJS/DOM/JSFFI/Generated/VideoTrack.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/VideoTrack.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/VideoTrack.hs
@@ -1,13 +1,19 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.VideoTrack
        (js_getId, getId, js_setKind, setKind, js_getKind, getKind,
         js_getLabel, getLabel, js_setLanguage, setLanguage, js_getLanguage,
         getLanguage, js_setSelected, setSelected, js_getSelected,
         getSelected, js_getSourceBuffer, getSourceBuffer,
-        getSourceBufferUnchecked, VideoTrack, castToVideoTrack,
+        getSourceBufferUnsafe, getSourceBufferUnchecked, VideoTrack(..),
         gTypeVideoTrack)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -23,6 +29,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"id\"]" js_getId ::
         VideoTrack -> IO JSString
@@ -94,6 +110,14 @@
                 (MonadIO m) => VideoTrack -> m (Maybe SourceBuffer)
 getSourceBuffer self
   = liftIO (nullableToMaybe <$> (js_getSourceBuffer (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/VideoTrack.sourceBuffer Mozilla VideoTrack.sourceBuffer documentation> 
+getSourceBufferUnsafe ::
+                      (MonadIO m, HasCallStack) => VideoTrack -> m SourceBuffer
+getSourceBufferUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getSourceBuffer (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/VideoTrack.sourceBuffer Mozilla VideoTrack.sourceBuffer documentation> 
 getSourceBufferUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/VideoTrackList.hs b/src/GHCJS/DOM/JSFFI/Generated/VideoTrackList.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/VideoTrackList.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/VideoTrackList.hs
@@ -1,12 +1,18 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.VideoTrackList
-       (js_item, item, item_, itemUnchecked, js_getTrackById,
-        getTrackById, getTrackById_, getTrackByIdUnchecked, js_getLength,
-        getLength, js_getSelectedIndex, getSelectedIndex, change, addTrack,
-        removeTrack, VideoTrackList, castToVideoTrackList,
-        gTypeVideoTrackList)
+       (js_item, item, item_, itemUnsafe, itemUnchecked, js_getTrackById,
+        getTrackById, getTrackById_, getTrackByIdUnsafe,
+        getTrackByIdUnchecked, js_getLength, getLength,
+        js_getSelectedIndex, getSelectedIndex, change, addTrack,
+        removeTrack, VideoTrackList(..), gTypeVideoTrackList)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -22,6 +28,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"item\"]($2)" js_item ::
         VideoTrackList -> Word -> IO (Nullable VideoTrack)
@@ -37,6 +53,14 @@
 item_ self index = liftIO (void (js_item (self) index))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/VideoTrackList.item Mozilla VideoTrackList.item documentation> 
+itemUnsafe ::
+           (MonadIO m, HasCallStack) => VideoTrackList -> Word -> m VideoTrack
+itemUnsafe self index
+  = liftIO
+      ((nullableToMaybe <$> (js_item (self) index)) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/VideoTrackList.item Mozilla VideoTrackList.item documentation> 
 itemUnchecked ::
               (MonadIO m) => VideoTrackList -> Word -> m VideoTrack
 itemUnchecked self index
@@ -59,6 +83,15 @@
               (MonadIO m, ToJSString id) => VideoTrackList -> id -> m ()
 getTrackById_ self id
   = liftIO (void (js_getTrackById (self) (toJSString id)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/VideoTrackList.getTrackById Mozilla VideoTrackList.getTrackById documentation> 
+getTrackByIdUnsafe ::
+                   (MonadIO m, ToJSString id, HasCallStack) =>
+                     VideoTrackList -> id -> m VideoTrack
+getTrackByIdUnsafe self id
+  = liftIO
+      ((nullableToMaybe <$> (js_getTrackById (self) (toJSString id))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/VideoTrackList.getTrackById Mozilla VideoTrackList.getTrackById documentation> 
 getTrackByIdUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/VoidCallback.hs b/src/GHCJS/DOM/JSFFI/Generated/VoidCallback.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/VoidCallback.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/VoidCallback.hs
@@ -1,9 +1,15 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.VoidCallback
        (newVoidCallback, newVoidCallbackSync, newVoidCallbackAsync,
         VoidCallback)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -19,6 +25,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/VoidCallback Mozilla VoidCallback documentation> 
 newVoidCallback :: (MonadIO m) => IO () -> m VoidCallback
diff --git a/src/GHCJS/DOM/JSFFI/Generated/WaveShaperNode.hs b/src/GHCJS/DOM/JSFFI/Generated/WaveShaperNode.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/WaveShaperNode.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/WaveShaperNode.hs
@@ -1,10 +1,17 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.WaveShaperNode
-       (js_setCurve, setCurve, js_getCurve, getCurve, getCurveUnchecked,
-        js_setOversample, setOversample, js_getOversample, getOversample,
-        WaveShaperNode, castToWaveShaperNode, gTypeWaveShaperNode)
+       (js_setCurve, setCurve, js_getCurve, getCurve, getCurveUnsafe,
+        getCurveUnchecked, js_setOversample, setOversample,
+        js_getOversample, getOversample, WaveShaperNode(..),
+        gTypeWaveShaperNode)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -20,6 +27,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"curve\"] = $2;" js_setCurve
         :: WaveShaperNode -> Nullable Float32Array -> IO ()
@@ -38,6 +55,14 @@
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/WaveShaperNode.curve Mozilla WaveShaperNode.curve documentation> 
 getCurve :: (MonadIO m) => WaveShaperNode -> m (Maybe Float32Array)
 getCurve self = liftIO (nullableToMaybe <$> (js_getCurve (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/WaveShaperNode.curve Mozilla WaveShaperNode.curve documentation> 
+getCurveUnsafe ::
+               (MonadIO m, HasCallStack) => WaveShaperNode -> m Float32Array
+getCurveUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getCurve (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/WaveShaperNode.curve Mozilla WaveShaperNode.curve documentation> 
 getCurveUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/WebGL2RenderingContext.hs b/src/GHCJS/DOM/JSFFI/Generated/WebGL2RenderingContext.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/WebGL2RenderingContext.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/WebGL2RenderingContext.hs
@@ -1,4 +1,9 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.WebGL2RenderingContext
        (js_copyBufferSubData, copyBufferSubData, js_getBufferSubDataView,
         getBufferSubDataView, js_getBufferSubData, getBufferSubData,
@@ -38,52 +43,54 @@
         drawBuffers, js_clearBufferiv, clearBufferiv, js_clearBufferuiv,
         clearBufferuiv, js_clearBufferfv, clearBufferfv, js_clearBufferfi,
         clearBufferfi, js_createQuery, createQuery, createQuery_,
-        createQueryUnchecked, js_deleteQuery, deleteQuery, js_isQuery,
-        isQuery, isQuery_, js_beginQuery, beginQuery, js_endQuery,
-        endQuery, js_getQuery, getQuery, getQuery_, getQueryUnchecked,
-        js_getQueryParameter, getQueryParameter, getQueryParameter_,
-        js_createSampler, createSampler, createSampler_,
+        createQueryUnsafe, createQueryUnchecked, js_deleteQuery,
+        deleteQuery, js_isQuery, isQuery, isQuery_, js_beginQuery,
+        beginQuery, js_endQuery, endQuery, js_getQuery, getQuery,
+        getQuery_, getQueryUnsafe, getQueryUnchecked, js_getQueryParameter,
+        getQueryParameter, getQueryParameter_, js_createSampler,
+        createSampler, createSampler_, createSamplerUnsafe,
         createSamplerUnchecked, js_deleteSampler, deleteSampler,
         js_isSampler, isSampler, isSampler_, js_bindSampler, bindSampler,
         js_samplerParameteri, samplerParameteri, js_samplerParameterf,
         samplerParameterf, js_getSamplerParameter, getSamplerParameter,
         getSamplerParameter_, js_fenceSync, fenceSync, fenceSync_,
-        fenceSyncUnchecked, js_isSync, isSync, isSync_, js_deleteSync,
-        deleteSync, js_clientWaitSync, clientWaitSync, clientWaitSync_,
-        js_waitSync, waitSync, js_getSyncParameter, getSyncParameter,
-        getSyncParameter_, js_createTransformFeedback,
+        fenceSyncUnsafe, fenceSyncUnchecked, js_isSync, isSync, isSync_,
+        js_deleteSync, deleteSync, js_clientWaitSync, clientWaitSync,
+        clientWaitSync_, js_waitSync, waitSync, js_getSyncParameter,
+        getSyncParameter, getSyncParameter_, js_createTransformFeedback,
         createTransformFeedback, createTransformFeedback_,
-        createTransformFeedbackUnchecked, js_deleteTransformFeedback,
-        deleteTransformFeedback, js_isTransformFeedback,
-        isTransformFeedback, isTransformFeedback_,
+        createTransformFeedbackUnsafe, createTransformFeedbackUnchecked,
+        js_deleteTransformFeedback, deleteTransformFeedback,
+        js_isTransformFeedback, isTransformFeedback, isTransformFeedback_,
         js_bindTransformFeedback, bindTransformFeedback,
         js_beginTransformFeedback, beginTransformFeedback,
         js_endTransformFeedback, endTransformFeedback,
         js_transformFeedbackVaryings, transformFeedbackVaryings,
         js_getTransformFeedbackVarying, getTransformFeedbackVarying,
-        getTransformFeedbackVarying_, getTransformFeedbackVaryingUnchecked,
-        js_pauseTransformFeedback, pauseTransformFeedback,
-        js_resumeTransformFeedback, resumeTransformFeedback,
-        js_bindBufferBase, bindBufferBase, js_bindBufferRange,
-        bindBufferRange, js_getIndexedParameter, getIndexedParameter,
-        getIndexedParameter_, js_getUniformIndices, getUniformIndices,
-        getUniformIndices_, getUniformIndicesUnchecked,
-        js_getActiveUniforms, getActiveUniforms, getActiveUniforms_,
+        getTransformFeedbackVarying_, getTransformFeedbackVaryingUnsafe,
+        getTransformFeedbackVaryingUnchecked, js_pauseTransformFeedback,
+        pauseTransformFeedback, js_resumeTransformFeedback,
+        resumeTransformFeedback, js_bindBufferBase, bindBufferBase,
+        js_bindBufferRange, bindBufferRange, js_getIndexedParameter,
+        getIndexedParameter, getIndexedParameter_, js_getUniformIndices,
+        getUniformIndices, getUniformIndices_, getUniformIndicesUnsafe,
+        getUniformIndicesUnchecked, js_getActiveUniforms,
+        getActiveUniforms, getActiveUniforms_, getActiveUniformsUnsafe,
         getActiveUniformsUnchecked, js_getUniformBlockIndex,
         getUniformBlockIndex, getUniformBlockIndex_,
         js_getActiveUniformBlockParameter, getActiveUniformBlockParameter,
         getActiveUniformBlockParameter_, js_getActiveUniformBlockName,
         getActiveUniformBlockName, getActiveUniformBlockName_,
         js_uniformBlockBinding, uniformBlockBinding, js_createVertexArray,
-        createVertexArray, createVertexArray_, createVertexArrayUnchecked,
-        js_deleteVertexArray, deleteVertexArray, js_isVertexArray,
-        isVertexArray, isVertexArray_, js_bindVertexArray, bindVertexArray,
-        pattern READ_BUFFER, pattern UNPACK_ROW_LENGTH,
-        pattern UNPACK_SKIP_ROWS, pattern UNPACK_SKIP_PIXELS,
-        pattern PACK_ROW_LENGTH, pattern PACK_SKIP_ROWS,
-        pattern PACK_SKIP_PIXELS, pattern COLOR, pattern DEPTH,
-        pattern STENCIL, pattern RED, pattern RGB8, pattern RGBA8,
-        pattern RGB10_A2, pattern TEXTURE_BINDING_3D,
+        createVertexArray, createVertexArray_, createVertexArrayUnsafe,
+        createVertexArrayUnchecked, js_deleteVertexArray,
+        deleteVertexArray, js_isVertexArray, isVertexArray, isVertexArray_,
+        js_bindVertexArray, bindVertexArray, pattern READ_BUFFER,
+        pattern UNPACK_ROW_LENGTH, pattern UNPACK_SKIP_ROWS,
+        pattern UNPACK_SKIP_PIXELS, pattern PACK_ROW_LENGTH,
+        pattern PACK_SKIP_ROWS, pattern PACK_SKIP_PIXELS, pattern COLOR,
+        pattern DEPTH, pattern STENCIL, pattern RED, pattern RGB8,
+        pattern RGBA8, pattern RGB10_A2, pattern TEXTURE_BINDING_3D,
         pattern UNPACK_SKIP_IMAGES, pattern UNPACK_IMAGE_HEIGHT,
         pattern TEXTURE_3D, pattern TEXTURE_WRAP_R,
         pattern MAX_3D_TEXTURE_SIZE, pattern UNSIGNED_INT_2_10_10_10_REV,
@@ -224,10 +231,11 @@
         pattern COMPRESSED_SRGB8_ALPHA8_ETC2_EAC,
         pattern TEXTURE_IMMUTABLE_FORMAT, pattern MAX_ELEMENT_INDEX,
         pattern NUM_SAMPLE_COUNTS, pattern TEXTURE_IMMUTABLE_LEVELS,
-        pattern TIMEOUT_IGNORED, WebGL2RenderingContext,
-        castToWebGL2RenderingContext, gTypeWebGL2RenderingContext)
+        pattern TIMEOUT_IGNORED, WebGL2RenderingContext(..),
+        gTypeWebGL2RenderingContext)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -243,6 +251,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe
         "$1[\"copyBufferSubData\"]($2, $3,\n$4, $5, $6)"
@@ -1184,6 +1202,14 @@
 createQuery_ self = liftIO (void (js_createQuery (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/WebGL2RenderingContext.createQuery Mozilla WebGL2RenderingContext.createQuery documentation> 
+createQueryUnsafe ::
+                  (MonadIO m, HasCallStack) => WebGL2RenderingContext -> m WebGLQuery
+createQueryUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_createQuery (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/WebGL2RenderingContext.createQuery Mozilla WebGL2RenderingContext.createQuery documentation> 
 createQueryUnchecked ::
                      (MonadIO m) => WebGL2RenderingContext -> m WebGLQuery
 createQueryUnchecked self
@@ -1252,6 +1278,15 @@
   = liftIO (void (js_getQuery (self) target pname))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/WebGL2RenderingContext.getQuery Mozilla WebGL2RenderingContext.getQuery documentation> 
+getQueryUnsafe ::
+               (MonadIO m, HasCallStack) =>
+                 WebGL2RenderingContext -> GLenum -> GLenum -> m WebGLQuery
+getQueryUnsafe self target pname
+  = liftIO
+      ((nullableToMaybe <$> (js_getQuery (self) target pname)) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/WebGL2RenderingContext.getQuery Mozilla WebGL2RenderingContext.getQuery documentation> 
 getQueryUnchecked ::
                   (MonadIO m) =>
                     WebGL2RenderingContext -> GLenum -> GLenum -> m WebGLQuery
@@ -1294,6 +1329,15 @@
 createSampler_ self = liftIO (void (js_createSampler (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/WebGL2RenderingContext.createSampler Mozilla WebGL2RenderingContext.createSampler documentation> 
+createSamplerUnsafe ::
+                    (MonadIO m, HasCallStack) =>
+                      WebGL2RenderingContext -> m WebGLSampler
+createSamplerUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_createSampler (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/WebGL2RenderingContext.createSampler Mozilla WebGL2RenderingContext.createSampler documentation> 
 createSamplerUnchecked ::
                        (MonadIO m) => WebGL2RenderingContext -> m WebGLSampler
 createSamplerUnchecked self
@@ -1409,6 +1453,15 @@
   = liftIO (void (js_fenceSync (self) condition flags))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/WebGL2RenderingContext.fenceSync Mozilla WebGL2RenderingContext.fenceSync documentation> 
+fenceSyncUnsafe ::
+                (MonadIO m, HasCallStack) =>
+                  WebGL2RenderingContext -> GLenum -> GLbitfield -> m WebGLSync
+fenceSyncUnsafe self condition flags
+  = liftIO
+      ((nullableToMaybe <$> (js_fenceSync (self) condition flags)) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/WebGL2RenderingContext.fenceSync Mozilla WebGL2RenderingContext.fenceSync documentation> 
 fenceSyncUnchecked ::
                    (MonadIO m) =>
                      WebGL2RenderingContext -> GLenum -> GLbitfield -> m WebGLSync
@@ -1520,6 +1573,15 @@
   = liftIO (void (js_createTransformFeedback (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/WebGL2RenderingContext.createTransformFeedback Mozilla WebGL2RenderingContext.createTransformFeedback documentation> 
+createTransformFeedbackUnsafe ::
+                              (MonadIO m, HasCallStack) =>
+                                WebGL2RenderingContext -> m WebGLTransformFeedback
+createTransformFeedbackUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_createTransformFeedback (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/WebGL2RenderingContext.createTransformFeedback Mozilla WebGL2RenderingContext.createTransformFeedback documentation> 
 createTransformFeedbackUnchecked ::
                                  (MonadIO m) => WebGL2RenderingContext -> m WebGLTransformFeedback
 createTransformFeedbackUnchecked self
@@ -1639,6 +1701,18 @@
             index))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/WebGL2RenderingContext.getTransformFeedbackVarying Mozilla WebGL2RenderingContext.getTransformFeedbackVarying documentation> 
+getTransformFeedbackVaryingUnsafe ::
+                                  (MonadIO m, HasCallStack) =>
+                                    WebGL2RenderingContext ->
+                                      Maybe WebGLProgram -> GLuint -> m WebGLActiveInfo
+getTransformFeedbackVaryingUnsafe self program index
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_getTransformFeedbackVarying (self) (maybeToNullable program)
+             index))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/WebGL2RenderingContext.getTransformFeedbackVarying Mozilla WebGL2RenderingContext.getTransformFeedbackVarying documentation> 
 getTransformFeedbackVaryingUnchecked ::
                                      (MonadIO m) =>
                                        WebGL2RenderingContext ->
@@ -1750,6 +1824,20 @@
                 uniformNames'))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/WebGL2RenderingContext.getUniformIndices Mozilla WebGL2RenderingContext.getUniformIndices documentation> 
+getUniformIndicesUnsafe ::
+                        (MonadIO m, ToJSString uniformNames, HasCallStack) =>
+                          WebGL2RenderingContext ->
+                            Maybe WebGLProgram -> [uniformNames] -> m Uint32Array
+getUniformIndicesUnsafe self program uniformNames
+  = liftIO
+      ((nullableToMaybe <$>
+          (toJSVal uniformNames >>=
+             \ uniformNames' ->
+               js_getUniformIndices (self) (maybeToNullable program)
+                 uniformNames'))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/WebGL2RenderingContext.getUniformIndices Mozilla WebGL2RenderingContext.getUniformIndices documentation> 
 getUniformIndicesUnchecked ::
                            (MonadIO m, ToJSString uniformNames) =>
                              WebGL2RenderingContext ->
@@ -1794,6 +1882,20 @@
             pname))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/WebGL2RenderingContext.getActiveUniforms Mozilla WebGL2RenderingContext.getActiveUniforms documentation> 
+getActiveUniformsUnsafe ::
+                        (MonadIO m, IsUint32Array uniformIndices, HasCallStack) =>
+                          WebGL2RenderingContext ->
+                            Maybe WebGLProgram ->
+                              Maybe uniformIndices -> GLenum -> m Int32Array
+getActiveUniformsUnsafe self program uniformIndices pname
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_getActiveUniforms (self) (maybeToNullable program)
+             (maybeToNullable (fmap toUint32Array uniformIndices))
+             pname))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/WebGL2RenderingContext.getActiveUniforms Mozilla WebGL2RenderingContext.getActiveUniforms documentation> 
 getActiveUniformsUnchecked ::
                            (MonadIO m, IsUint32Array uniformIndices) =>
                              WebGL2RenderingContext ->
@@ -1920,6 +2022,15 @@
 createVertexArray_ :: (MonadIO m) => WebGL2RenderingContext -> m ()
 createVertexArray_ self
   = liftIO (void (js_createVertexArray (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/WebGL2RenderingContext.createVertexArray Mozilla WebGL2RenderingContext.createVertexArray documentation> 
+createVertexArrayUnsafe ::
+                        (MonadIO m, HasCallStack) =>
+                          WebGL2RenderingContext -> m WebGLVertexArrayObject
+createVertexArrayUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_createVertexArray (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/WebGL2RenderingContext.createVertexArray Mozilla WebGL2RenderingContext.createVertexArray documentation> 
 createVertexArrayUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/WebGLActiveInfo.hs b/src/GHCJS/DOM/JSFFI/Generated/WebGLActiveInfo.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/WebGLActiveInfo.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/WebGLActiveInfo.hs
@@ -1,9 +1,15 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.WebGLActiveInfo
        (js_getSize, getSize, js_getType, getType, js_getName, getName,
-        WebGLActiveInfo, castToWebGLActiveInfo, gTypeWebGLActiveInfo)
+        WebGLActiveInfo(..), gTypeWebGLActiveInfo)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -19,6 +25,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"size\"]" js_getSize ::
         WebGLActiveInfo -> IO Int
diff --git a/src/GHCJS/DOM/JSFFI/Generated/WebGLCompressedTextureATC.hs b/src/GHCJS/DOM/JSFFI/Generated/WebGLCompressedTextureATC.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/WebGLCompressedTextureATC.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/WebGLCompressedTextureATC.hs
@@ -1,12 +1,17 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.WebGLCompressedTextureATC
        (pattern COMPRESSED_RGB_ATC_WEBGL,
         pattern COMPRESSED_RGBA_ATC_EXPLICIT_ALPHA_WEBGL,
         pattern COMPRESSED_RGBA_ATC_INTERPOLATED_ALPHA_WEBGL,
-        WebGLCompressedTextureATC, castToWebGLCompressedTextureATC,
-        gTypeWebGLCompressedTextureATC)
+        WebGLCompressedTextureATC(..), gTypeWebGLCompressedTextureATC)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -22,6 +27,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
 pattern COMPRESSED_RGB_ATC_WEBGL = 35986
 pattern COMPRESSED_RGBA_ATC_EXPLICIT_ALPHA_WEBGL = 35987
 pattern COMPRESSED_RGBA_ATC_INTERPOLATED_ALPHA_WEBGL = 34798
diff --git a/src/GHCJS/DOM/JSFFI/Generated/WebGLCompressedTexturePVRTC.hs b/src/GHCJS/DOM/JSFFI/Generated/WebGLCompressedTexturePVRTC.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/WebGLCompressedTexturePVRTC.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/WebGLCompressedTexturePVRTC.hs
@@ -1,13 +1,18 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.WebGLCompressedTexturePVRTC
        (pattern COMPRESSED_RGB_PVRTC_4BPPV1_IMG,
         pattern COMPRESSED_RGB_PVRTC_2BPPV1_IMG,
         pattern COMPRESSED_RGBA_PVRTC_4BPPV1_IMG,
         pattern COMPRESSED_RGBA_PVRTC_2BPPV1_IMG,
-        WebGLCompressedTexturePVRTC, castToWebGLCompressedTexturePVRTC,
-        gTypeWebGLCompressedTexturePVRTC)
+        WebGLCompressedTexturePVRTC(..), gTypeWebGLCompressedTexturePVRTC)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -23,6 +28,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
 pattern COMPRESSED_RGB_PVRTC_4BPPV1_IMG = 35840
 pattern COMPRESSED_RGB_PVRTC_2BPPV1_IMG = 35841
 pattern COMPRESSED_RGBA_PVRTC_4BPPV1_IMG = 35842
diff --git a/src/GHCJS/DOM/JSFFI/Generated/WebGLCompressedTextureS3TC.hs b/src/GHCJS/DOM/JSFFI/Generated/WebGLCompressedTextureS3TC.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/WebGLCompressedTextureS3TC.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/WebGLCompressedTextureS3TC.hs
@@ -1,12 +1,18 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.WebGLCompressedTextureS3TC
        (pattern COMPRESSED_RGB_S3TC_DXT1_EXT,
         pattern COMPRESSED_RGBA_S3TC_DXT1_EXT,
         pattern COMPRESSED_RGBA_S3TC_DXT3_EXT,
-        pattern COMPRESSED_RGBA_S3TC_DXT5_EXT, WebGLCompressedTextureS3TC,
-        castToWebGLCompressedTextureS3TC, gTypeWebGLCompressedTextureS3TC)
+        pattern COMPRESSED_RGBA_S3TC_DXT5_EXT,
+        WebGLCompressedTextureS3TC(..), gTypeWebGLCompressedTextureS3TC)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -22,6 +28,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
 pattern COMPRESSED_RGB_S3TC_DXT1_EXT = 33776
 pattern COMPRESSED_RGBA_S3TC_DXT1_EXT = 33777
 pattern COMPRESSED_RGBA_S3TC_DXT3_EXT = 33778
diff --git a/src/GHCJS/DOM/JSFFI/Generated/WebGLContextAttributes.hs b/src/GHCJS/DOM/JSFFI/Generated/WebGLContextAttributes.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/WebGLContextAttributes.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/WebGLContextAttributes.hs
@@ -1,4 +1,9 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.WebGLContextAttributes
        (js_setAlpha, setAlpha, js_getAlpha, getAlpha, js_setDepth,
         setDepth, js_getDepth, getDepth, js_setStencil, setStencil,
@@ -7,10 +12,11 @@
         setPremultipliedAlpha, js_getPremultipliedAlpha,
         getPremultipliedAlpha, js_setPreserveDrawingBuffer,
         setPreserveDrawingBuffer, js_getPreserveDrawingBuffer,
-        getPreserveDrawingBuffer, WebGLContextAttributes,
-        castToWebGLContextAttributes, gTypeWebGLContextAttributes)
+        getPreserveDrawingBuffer, WebGLContextAttributes(..),
+        gTypeWebGLContextAttributes)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -26,6 +32,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"alpha\"] = $2;" js_setAlpha
         :: WebGLContextAttributes -> Bool -> IO ()
diff --git a/src/GHCJS/DOM/JSFFI/Generated/WebGLContextEvent.hs b/src/GHCJS/DOM/JSFFI/Generated/WebGLContextEvent.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/WebGLContextEvent.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/WebGLContextEvent.hs
@@ -1,9 +1,15 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.WebGLContextEvent
-       (js_getStatusMessage, getStatusMessage, WebGLContextEvent,
-        castToWebGLContextEvent, gTypeWebGLContextEvent)
+       (js_getStatusMessage, getStatusMessage, WebGLContextEvent(..),
+        gTypeWebGLContextEvent)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -19,6 +25,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"statusMessage\"]"
         js_getStatusMessage :: WebGLContextEvent -> IO JSString
diff --git a/src/GHCJS/DOM/JSFFI/Generated/WebGLDebugRendererInfo.hs b/src/GHCJS/DOM/JSFFI/Generated/WebGLDebugRendererInfo.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/WebGLDebugRendererInfo.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/WebGLDebugRendererInfo.hs
@@ -1,10 +1,15 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.WebGLDebugRendererInfo
        (pattern UNMASKED_VENDOR_WEBGL, pattern UNMASKED_RENDERER_WEBGL,
-        WebGLDebugRendererInfo, castToWebGLDebugRendererInfo,
-        gTypeWebGLDebugRendererInfo)
+        WebGLDebugRendererInfo(..), gTypeWebGLDebugRendererInfo)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -20,5 +25,15 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
 pattern UNMASKED_VENDOR_WEBGL = 37445
 pattern UNMASKED_RENDERER_WEBGL = 37446
diff --git a/src/GHCJS/DOM/JSFFI/Generated/WebGLDebugShaders.hs b/src/GHCJS/DOM/JSFFI/Generated/WebGLDebugShaders.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/WebGLDebugShaders.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/WebGLDebugShaders.hs
@@ -1,10 +1,17 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.WebGLDebugShaders
        (js_getTranslatedShaderSource, getTranslatedShaderSource,
-        getTranslatedShaderSource_, getTranslatedShaderSourceUnchecked,
-        WebGLDebugShaders, castToWebGLDebugShaders, gTypeWebGLDebugShaders)
+        getTranslatedShaderSource_, getTranslatedShaderSourceUnsafe,
+        getTranslatedShaderSourceUnchecked, WebGLDebugShaders(..),
+        gTypeWebGLDebugShaders)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -20,6 +27,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe
         "$1[\"getTranslatedShaderSource\"]($2)"
@@ -42,6 +59,16 @@
   = liftIO
       (void
          (js_getTranslatedShaderSource (self) (maybeToNullable shader)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/WebGLDebugShaders.getTranslatedShaderSource Mozilla WebGLDebugShaders.getTranslatedShaderSource documentation> 
+getTranslatedShaderSourceUnsafe ::
+                                (MonadIO m, HasCallStack, FromJSString result) =>
+                                  WebGLDebugShaders -> Maybe WebGLShader -> m result
+getTranslatedShaderSourceUnsafe self shader
+  = liftIO
+      ((fromMaybeJSString <$>
+          (js_getTranslatedShaderSource (self) (maybeToNullable shader)))
+         >>= maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/WebGLDebugShaders.getTranslatedShaderSource Mozilla WebGLDebugShaders.getTranslatedShaderSource documentation> 
 getTranslatedShaderSourceUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/WebGLDepthTexture.hs b/src/GHCJS/DOM/JSFFI/Generated/WebGLDepthTexture.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/WebGLDepthTexture.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/WebGLDepthTexture.hs
@@ -1,9 +1,15 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.WebGLDepthTexture
-       (pattern UNSIGNED_INT_24_8_WEBGL, WebGLDepthTexture,
-        castToWebGLDepthTexture, gTypeWebGLDepthTexture)
+       (pattern UNSIGNED_INT_24_8_WEBGL, WebGLDepthTexture(..),
+        gTypeWebGLDepthTexture)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -19,4 +25,14 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
 pattern UNSIGNED_INT_24_8_WEBGL = 34042
diff --git a/src/GHCJS/DOM/JSFFI/Generated/WebGLDrawBuffers.hs b/src/GHCJS/DOM/JSFFI/Generated/WebGLDrawBuffers.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/WebGLDrawBuffers.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/WebGLDrawBuffers.hs
@@ -1,4 +1,9 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.WebGLDrawBuffers
        (js_drawBuffersWEBGL, drawBuffersWEBGL,
         pattern COLOR_ATTACHMENT0_WEBGL, pattern COLOR_ATTACHMENT1_WEBGL,
@@ -18,10 +23,11 @@
         pattern DRAW_BUFFER12_WEBGL, pattern DRAW_BUFFER13_WEBGL,
         pattern DRAW_BUFFER14_WEBGL, pattern DRAW_BUFFER15_WEBGL,
         pattern MAX_COLOR_ATTACHMENTS_WEBGL,
-        pattern MAX_DRAW_BUFFERS_WEBGL, WebGLDrawBuffers,
-        castToWebGLDrawBuffers, gTypeWebGLDrawBuffers)
+        pattern MAX_DRAW_BUFFERS_WEBGL, WebGLDrawBuffers(..),
+        gTypeWebGLDrawBuffers)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -37,6 +43,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"drawBuffersWEBGL\"]($2)"
         js_drawBuffersWEBGL :: WebGLDrawBuffers -> JSVal -> IO ()
diff --git a/src/GHCJS/DOM/JSFFI/Generated/WebGLLoseContext.hs b/src/GHCJS/DOM/JSFFI/Generated/WebGLLoseContext.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/WebGLLoseContext.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/WebGLLoseContext.hs
@@ -1,9 +1,15 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.WebGLLoseContext
        (js_loseContext, loseContext, js_restoreContext, restoreContext,
-        WebGLLoseContext, castToWebGLLoseContext, gTypeWebGLLoseContext)
+        WebGLLoseContext(..), gTypeWebGLLoseContext)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -19,6 +25,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"loseContext\"]()"
         js_loseContext :: WebGLLoseContext -> IO ()
diff --git a/src/GHCJS/DOM/JSFFI/Generated/WebGLRenderingContextBase.hs b/src/GHCJS/DOM/JSFFI/Generated/WebGLRenderingContextBase.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/WebGLRenderingContextBase.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/WebGLRenderingContextBase.hs
@@ -1,4 +1,9 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.WebGLRenderingContextBase
        (js_activeTexture, activeTexture, js_attachShader, attachShader,
         js_bindAttribLocation, bindAttribLocation, js_bindBuffer,
@@ -17,20 +22,22 @@
         compressedTexImage2D, js_compressedTexSubImage2D,
         compressedTexSubImage2D, js_copyTexImage2D, copyTexImage2D,
         js_copyTexSubImage2D, copyTexSubImage2D, js_createBuffer,
-        createBuffer, createBuffer_, createBufferUnchecked,
-        js_createFramebuffer, createFramebuffer, createFramebuffer_,
+        createBuffer, createBuffer_, createBufferUnsafe,
+        createBufferUnchecked, js_createFramebuffer, createFramebuffer,
+        createFramebuffer_, createFramebufferUnsafe,
         createFramebufferUnchecked, js_createProgram, createProgram,
-        createProgram_, createProgramUnchecked, js_createRenderbuffer,
-        createRenderbuffer, createRenderbuffer_,
-        createRenderbufferUnchecked, js_createShader, createShader,
-        createShader_, createShaderUnchecked, js_createTexture,
-        createTexture, createTexture_, createTextureUnchecked, js_cullFace,
-        cullFace, js_deleteBuffer, deleteBuffer, js_deleteFramebuffer,
-        deleteFramebuffer, js_deleteProgram, deleteProgram,
-        js_deleteRenderbuffer, deleteRenderbuffer, js_deleteShader,
-        deleteShader, js_deleteTexture, deleteTexture, js_depthFunc,
-        depthFunc, js_depthMask, depthMask, js_depthRange, depthRange,
-        js_detachShader, detachShader, js_disable, disable,
+        createProgram_, createProgramUnsafe, createProgramUnchecked,
+        js_createRenderbuffer, createRenderbuffer, createRenderbuffer_,
+        createRenderbufferUnsafe, createRenderbufferUnchecked,
+        js_createShader, createShader, createShader_, createShaderUnsafe,
+        createShaderUnchecked, js_createTexture, createTexture,
+        createTexture_, createTextureUnsafe, createTextureUnchecked,
+        js_cullFace, cullFace, js_deleteBuffer, deleteBuffer,
+        js_deleteFramebuffer, deleteFramebuffer, js_deleteProgram,
+        deleteProgram, js_deleteRenderbuffer, deleteRenderbuffer,
+        js_deleteShader, deleteShader, js_deleteTexture, deleteTexture,
+        js_depthFunc, depthFunc, js_depthMask, depthMask, js_depthRange,
+        depthRange, js_detachShader, detachShader, js_disable, disable,
         js_disableVertexAttribArray, disableVertexAttribArray,
         js_drawArrays, drawArrays, js_drawElements, drawElements,
         js_enable, enable, js_enableVertexAttribArray,
@@ -38,32 +45,36 @@
         js_framebufferRenderbuffer, framebufferRenderbuffer,
         js_framebufferTexture2D, framebufferTexture2D, js_frontFace,
         frontFace, js_generateMipmap, generateMipmap, js_getActiveAttrib,
-        getActiveAttrib, getActiveAttrib_, getActiveAttribUnchecked,
-        js_getActiveUniform, getActiveUniform, getActiveUniform_,
+        getActiveAttrib, getActiveAttrib_, getActiveAttribUnsafe,
+        getActiveAttribUnchecked, js_getActiveUniform, getActiveUniform,
+        getActiveUniform_, getActiveUniformUnsafe,
         getActiveUniformUnchecked, js_getAttachedShaders,
         getAttachedShaders, js_getAttribLocation, getAttribLocation,
         getAttribLocation_, js_getBufferParameter, getBufferParameter,
         getBufferParameter_, js_getContextAttributes, getContextAttributes,
-        getContextAttributes_, getContextAttributesUnchecked, js_getError,
-        getError, getError_, js_getExtension, getExtension, getExtension_,
+        getContextAttributes_, getContextAttributesUnsafe,
+        getContextAttributesUnchecked, js_getError, getError, getError_,
+        js_getExtension, getExtension, getExtension_,
         js_getFramebufferAttachmentParameter,
         getFramebufferAttachmentParameter,
         getFramebufferAttachmentParameter_, js_getParameter, getParameter,
         getParameter_, js_getProgramParameter, getProgramParameter,
         getProgramParameter_, js_getProgramInfoLog, getProgramInfoLog,
-        getProgramInfoLog_, getProgramInfoLogUnchecked,
-        js_getRenderbufferParameter, getRenderbufferParameter,
-        getRenderbufferParameter_, js_getShaderParameter,
-        getShaderParameter, getShaderParameter_, js_getShaderInfoLog,
-        getShaderInfoLog, getShaderInfoLog_, getShaderInfoLogUnchecked,
+        getProgramInfoLog_, getProgramInfoLogUnsafe,
+        getProgramInfoLogUnchecked, js_getRenderbufferParameter,
+        getRenderbufferParameter, getRenderbufferParameter_,
+        js_getShaderParameter, getShaderParameter, getShaderParameter_,
+        js_getShaderInfoLog, getShaderInfoLog, getShaderInfoLog_,
+        getShaderInfoLogUnsafe, getShaderInfoLogUnchecked,
         js_getShaderPrecisionFormat, getShaderPrecisionFormat,
-        getShaderPrecisionFormat_, getShaderPrecisionFormatUnchecked,
-        js_getShaderSource, getShaderSource, getShaderSource_,
+        getShaderPrecisionFormat_, getShaderPrecisionFormatUnsafe,
+        getShaderPrecisionFormatUnchecked, js_getShaderSource,
+        getShaderSource, getShaderSource_, getShaderSourceUnsafe,
         getShaderSourceUnchecked, js_getSupportedExtensions,
         getSupportedExtensions, getSupportedExtensions_,
         js_getTexParameter, getTexParameter, getTexParameter_,
         js_getUniform, getUniform, getUniform_, js_getUniformLocation,
-        getUniformLocation, getUniformLocation_,
+        getUniformLocation, getUniformLocation_, getUniformLocationUnsafe,
         getUniformLocationUnchecked, js_getVertexAttrib, getVertexAttrib,
         getVertexAttrib_, js_getVertexAttribOffset, getVertexAttribOffset,
         getVertexAttribOffset_, js_hint, hint, js_isBuffer, isBuffer,
@@ -242,11 +253,12 @@
         pattern UNPACK_COLORSPACE_CONVERSION_WEBGL,
         pattern BROWSER_DEFAULT_WEBGL, js_getDrawingBufferWidth,
         getDrawingBufferWidth, js_getDrawingBufferHeight,
-        getDrawingBufferHeight, WebGLRenderingContextBase,
-        castToWebGLRenderingContextBase, gTypeWebGLRenderingContextBase,
-        IsWebGLRenderingContextBase, toWebGLRenderingContextBase)
+        getDrawingBufferHeight, WebGLRenderingContextBase(..),
+        gTypeWebGLRenderingContextBase, IsWebGLRenderingContextBase,
+        toWebGLRenderingContextBase)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -262,6 +274,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"activeTexture\"]($2)"
         js_activeTexture :: WebGLRenderingContextBase -> GLenum -> IO ()
@@ -734,6 +756,16 @@
       (void (js_createBuffer (toWebGLRenderingContextBase self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/WebGLRenderingContextBase.createBuffer Mozilla WebGLRenderingContextBase.createBuffer documentation> 
+createBufferUnsafe ::
+                   (MonadIO m, IsWebGLRenderingContextBase self, HasCallStack) =>
+                     self -> m WebGLBuffer
+createBufferUnsafe self
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_createBuffer (toWebGLRenderingContextBase self)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/WebGLRenderingContextBase.createBuffer Mozilla WebGLRenderingContextBase.createBuffer documentation> 
 createBufferUnchecked ::
                       (MonadIO m, IsWebGLRenderingContextBase self) =>
                         self -> m WebGLBuffer
@@ -763,6 +795,16 @@
       (void (js_createFramebuffer (toWebGLRenderingContextBase self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/WebGLRenderingContextBase.createFramebuffer Mozilla WebGLRenderingContextBase.createFramebuffer documentation> 
+createFramebufferUnsafe ::
+                        (MonadIO m, IsWebGLRenderingContextBase self, HasCallStack) =>
+                          self -> m WebGLFramebuffer
+createFramebufferUnsafe self
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_createFramebuffer (toWebGLRenderingContextBase self)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/WebGLRenderingContextBase.createFramebuffer Mozilla WebGLRenderingContextBase.createFramebuffer documentation> 
 createFramebufferUnchecked ::
                            (MonadIO m, IsWebGLRenderingContextBase self) =>
                              self -> m WebGLFramebuffer
@@ -792,6 +834,16 @@
       (void (js_createProgram (toWebGLRenderingContextBase self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/WebGLRenderingContextBase.createProgram Mozilla WebGLRenderingContextBase.createProgram documentation> 
+createProgramUnsafe ::
+                    (MonadIO m, IsWebGLRenderingContextBase self, HasCallStack) =>
+                      self -> m WebGLProgram
+createProgramUnsafe self
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_createProgram (toWebGLRenderingContextBase self)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/WebGLRenderingContextBase.createProgram Mozilla WebGLRenderingContextBase.createProgram documentation> 
 createProgramUnchecked ::
                        (MonadIO m, IsWebGLRenderingContextBase self) =>
                          self -> m WebGLProgram
@@ -821,6 +873,16 @@
       (void (js_createRenderbuffer (toWebGLRenderingContextBase self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/WebGLRenderingContextBase.createRenderbuffer Mozilla WebGLRenderingContextBase.createRenderbuffer documentation> 
+createRenderbufferUnsafe ::
+                         (MonadIO m, IsWebGLRenderingContextBase self, HasCallStack) =>
+                           self -> m WebGLRenderbuffer
+createRenderbufferUnsafe self
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_createRenderbuffer (toWebGLRenderingContextBase self)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/WebGLRenderingContextBase.createRenderbuffer Mozilla WebGLRenderingContextBase.createRenderbuffer documentation> 
 createRenderbufferUnchecked ::
                             (MonadIO m, IsWebGLRenderingContextBase self) =>
                               self -> m WebGLRenderbuffer
@@ -851,6 +913,16 @@
       (void (js_createShader (toWebGLRenderingContextBase self) type'))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/WebGLRenderingContextBase.createShader Mozilla WebGLRenderingContextBase.createShader documentation> 
+createShaderUnsafe ::
+                   (MonadIO m, IsWebGLRenderingContextBase self, HasCallStack) =>
+                     self -> GLenum -> m WebGLShader
+createShaderUnsafe self type'
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_createShader (toWebGLRenderingContextBase self) type'))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/WebGLRenderingContextBase.createShader Mozilla WebGLRenderingContextBase.createShader documentation> 
 createShaderUnchecked ::
                       (MonadIO m, IsWebGLRenderingContextBase self) =>
                         self -> GLenum -> m WebGLShader
@@ -880,6 +952,16 @@
       (void (js_createTexture (toWebGLRenderingContextBase self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/WebGLRenderingContextBase.createTexture Mozilla WebGLRenderingContextBase.createTexture documentation> 
+createTextureUnsafe ::
+                    (MonadIO m, IsWebGLRenderingContextBase self, HasCallStack) =>
+                      self -> m WebGLTexture
+createTextureUnsafe self
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_createTexture (toWebGLRenderingContextBase self)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/WebGLRenderingContextBase.createTexture Mozilla WebGLRenderingContextBase.createTexture documentation> 
 createTextureUnchecked ::
                        (MonadIO m, IsWebGLRenderingContextBase self) =>
                          self -> m WebGLTexture
@@ -1201,6 +1283,18 @@
             index))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/WebGLRenderingContextBase.getActiveAttrib Mozilla WebGLRenderingContextBase.getActiveAttrib documentation> 
+getActiveAttribUnsafe ::
+                      (MonadIO m, IsWebGLRenderingContextBase self, HasCallStack) =>
+                        self -> Maybe WebGLProgram -> GLuint -> m WebGLActiveInfo
+getActiveAttribUnsafe self program index
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_getActiveAttrib (toWebGLRenderingContextBase self)
+             (maybeToNullable program)
+             index))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/WebGLRenderingContextBase.getActiveAttrib Mozilla WebGLRenderingContextBase.getActiveAttrib documentation> 
 getActiveAttribUnchecked ::
                          (MonadIO m, IsWebGLRenderingContextBase self) =>
                            self -> Maybe WebGLProgram -> GLuint -> m WebGLActiveInfo
@@ -1239,6 +1333,18 @@
             index))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/WebGLRenderingContextBase.getActiveUniform Mozilla WebGLRenderingContextBase.getActiveUniform documentation> 
+getActiveUniformUnsafe ::
+                       (MonadIO m, IsWebGLRenderingContextBase self, HasCallStack) =>
+                         self -> Maybe WebGLProgram -> GLuint -> m WebGLActiveInfo
+getActiveUniformUnsafe self program index
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_getActiveUniform (toWebGLRenderingContextBase self)
+             (maybeToNullable program)
+             index))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/WebGLRenderingContextBase.getActiveUniform Mozilla WebGLRenderingContextBase.getActiveUniform documentation> 
 getActiveUniformUnchecked ::
                           (MonadIO m, IsWebGLRenderingContextBase self) =>
                             self -> Maybe WebGLProgram -> GLuint -> m WebGLActiveInfo
@@ -1332,6 +1438,16 @@
       (void (js_getContextAttributes (toWebGLRenderingContextBase self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/WebGLRenderingContextBase.getContextAttributes Mozilla WebGLRenderingContextBase.getContextAttributes documentation> 
+getContextAttributesUnsafe ::
+                           (MonadIO m, IsWebGLRenderingContextBase self, HasCallStack) =>
+                             self -> m WebGLContextAttributes
+getContextAttributesUnsafe self
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_getContextAttributes (toWebGLRenderingContextBase self)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/WebGLRenderingContextBase.getContextAttributes Mozilla WebGLRenderingContextBase.getContextAttributes documentation> 
 getContextAttributesUnchecked ::
                               (MonadIO m, IsWebGLRenderingContextBase self) =>
                                 self -> m WebGLContextAttributes
@@ -1479,6 +1595,18 @@
             (maybeToNullable program)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/WebGLRenderingContextBase.getProgramInfoLog Mozilla WebGLRenderingContextBase.getProgramInfoLog documentation> 
+getProgramInfoLogUnsafe ::
+                        (MonadIO m, IsWebGLRenderingContextBase self, HasCallStack,
+                         FromJSString result) =>
+                          self -> Maybe WebGLProgram -> m result
+getProgramInfoLogUnsafe self program
+  = liftIO
+      ((fromMaybeJSString <$>
+          (js_getProgramInfoLog (toWebGLRenderingContextBase self)
+             (maybeToNullable program)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/WebGLRenderingContextBase.getProgramInfoLog Mozilla WebGLRenderingContextBase.getProgramInfoLog documentation> 
 getProgramInfoLogUnchecked ::
                            (MonadIO m, IsWebGLRenderingContextBase self,
                             FromJSString result) =>
@@ -1568,6 +1696,18 @@
             (maybeToNullable shader)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/WebGLRenderingContextBase.getShaderInfoLog Mozilla WebGLRenderingContextBase.getShaderInfoLog documentation> 
+getShaderInfoLogUnsafe ::
+                       (MonadIO m, IsWebGLRenderingContextBase self, HasCallStack,
+                        FromJSString result) =>
+                         self -> Maybe WebGLShader -> m result
+getShaderInfoLogUnsafe self shader
+  = liftIO
+      ((fromMaybeJSString <$>
+          (js_getShaderInfoLog (toWebGLRenderingContextBase self)
+             (maybeToNullable shader)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/WebGLRenderingContextBase.getShaderInfoLog Mozilla WebGLRenderingContextBase.getShaderInfoLog documentation> 
 getShaderInfoLogUnchecked ::
                           (MonadIO m, IsWebGLRenderingContextBase self,
                            FromJSString result) =>
@@ -1607,6 +1747,18 @@
             precisiontype))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/WebGLRenderingContextBase.getShaderPrecisionFormat Mozilla WebGLRenderingContextBase.getShaderPrecisionFormat documentation> 
+getShaderPrecisionFormatUnsafe ::
+                               (MonadIO m, IsWebGLRenderingContextBase self, HasCallStack) =>
+                                 self -> GLenum -> GLenum -> m WebGLShaderPrecisionFormat
+getShaderPrecisionFormatUnsafe self shadertype precisiontype
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_getShaderPrecisionFormat (toWebGLRenderingContextBase self)
+             shadertype
+             precisiontype))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/WebGLRenderingContextBase.getShaderPrecisionFormat Mozilla WebGLRenderingContextBase.getShaderPrecisionFormat documentation> 
 getShaderPrecisionFormatUnchecked ::
                                   (MonadIO m, IsWebGLRenderingContextBase self) =>
                                     self -> GLenum -> GLenum -> m WebGLShaderPrecisionFormat
@@ -1644,6 +1796,18 @@
             (maybeToNullable shader)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/WebGLRenderingContextBase.getShaderSource Mozilla WebGLRenderingContextBase.getShaderSource documentation> 
+getShaderSourceUnsafe ::
+                      (MonadIO m, IsWebGLRenderingContextBase self, HasCallStack,
+                       FromJSString result) =>
+                        self -> Maybe WebGLShader -> m result
+getShaderSourceUnsafe self shader
+  = liftIO
+      ((fromMaybeJSString <$>
+          (js_getShaderSource (toWebGLRenderingContextBase self)
+             (maybeToNullable shader)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/WebGLRenderingContextBase.getShaderSource Mozilla WebGLRenderingContextBase.getShaderSource documentation> 
 getShaderSourceUnchecked ::
                          (MonadIO m, IsWebGLRenderingContextBase self,
                           FromJSString result) =>
@@ -1752,6 +1916,19 @@
          (js_getUniformLocation (toWebGLRenderingContextBase self)
             (maybeToNullable program)
             (toJSString name)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/WebGLRenderingContextBase.getUniformLocation Mozilla WebGLRenderingContextBase.getUniformLocation documentation> 
+getUniformLocationUnsafe ::
+                         (MonadIO m, IsWebGLRenderingContextBase self, ToJSString name,
+                          HasCallStack) =>
+                           self -> Maybe WebGLProgram -> name -> m WebGLUniformLocation
+getUniformLocationUnsafe self program name
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_getUniformLocation (toWebGLRenderingContextBase self)
+             (maybeToNullable program)
+             (toJSString name)))
+         >>= maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/WebGLRenderingContextBase.getUniformLocation Mozilla WebGLRenderingContextBase.getUniformLocation documentation> 
 getUniformLocationUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/WebGLShaderPrecisionFormat.hs b/src/GHCJS/DOM/JSFFI/Generated/WebGLShaderPrecisionFormat.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/WebGLShaderPrecisionFormat.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/WebGLShaderPrecisionFormat.hs
@@ -1,10 +1,16 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.WebGLShaderPrecisionFormat
        (js_getRangeMin, getRangeMin, js_getRangeMax, getRangeMax,
-        js_getPrecision, getPrecision, WebGLShaderPrecisionFormat,
-        castToWebGLShaderPrecisionFormat, gTypeWebGLShaderPrecisionFormat)
+        js_getPrecision, getPrecision, WebGLShaderPrecisionFormat(..),
+        gTypeWebGLShaderPrecisionFormat)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -20,6 +26,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"rangeMin\"]" js_getRangeMin
         :: WebGLShaderPrecisionFormat -> IO Int
diff --git a/src/GHCJS/DOM/JSFFI/Generated/WebKitAnimationEvent.hs b/src/GHCJS/DOM/JSFFI/Generated/WebKitAnimationEvent.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/WebKitAnimationEvent.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/WebKitAnimationEvent.hs
@@ -1,10 +1,16 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.WebKitAnimationEvent
        (js_getAnimationName, getAnimationName, js_getElapsedTime,
-        getElapsedTime, WebKitAnimationEvent, castToWebKitAnimationEvent,
+        getElapsedTime, WebKitAnimationEvent(..),
         gTypeWebKitAnimationEvent)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -20,6 +26,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"animationName\"]"
         js_getAnimationName :: WebKitAnimationEvent -> IO JSString
diff --git a/src/GHCJS/DOM/JSFFI/Generated/WebKitCSSFilterValue.hs b/src/GHCJS/DOM/JSFFI/Generated/WebKitCSSFilterValue.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/WebKitCSSFilterValue.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/WebKitCSSFilterValue.hs
@@ -1,15 +1,22 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.WebKitCSSFilterValue
-       (js__get, _get, _get_, _getUnchecked, pattern CSS_FILTER_REFERENCE,
-        pattern CSS_FILTER_GRAYSCALE, pattern CSS_FILTER_SEPIA,
-        pattern CSS_FILTER_SATURATE, pattern CSS_FILTER_HUE_ROTATE,
-        pattern CSS_FILTER_INVERT, pattern CSS_FILTER_OPACITY,
-        pattern CSS_FILTER_BRIGHTNESS, pattern CSS_FILTER_CONTRAST,
-        pattern CSS_FILTER_BLUR, pattern CSS_FILTER_DROP_SHADOW,
-        js_getOperationType, getOperationType, WebKitCSSFilterValue,
-        castToWebKitCSSFilterValue, gTypeWebKitCSSFilterValue)
+       (js__get, _get, _get_, _getUnsafe, _getUnchecked,
+        pattern CSS_FILTER_REFERENCE, pattern CSS_FILTER_GRAYSCALE,
+        pattern CSS_FILTER_SEPIA, pattern CSS_FILTER_SATURATE,
+        pattern CSS_FILTER_HUE_ROTATE, pattern CSS_FILTER_INVERT,
+        pattern CSS_FILTER_OPACITY, pattern CSS_FILTER_BRIGHTNESS,
+        pattern CSS_FILTER_CONTRAST, pattern CSS_FILTER_BLUR,
+        pattern CSS_FILTER_DROP_SHADOW, js_getOperationType,
+        getOperationType, WebKitCSSFilterValue(..),
+        gTypeWebKitCSSFilterValue)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -25,6 +32,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"_get\"]($2)" js__get ::
         WebKitCSSFilterValue -> Word -> IO (Nullable CSSValue)
@@ -38,6 +55,15 @@
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/WebKitCSSFilterValue._get Mozilla WebKitCSSFilterValue._get documentation> 
 _get_ :: (MonadIO m) => WebKitCSSFilterValue -> Word -> m ()
 _get_ self index = liftIO (void (js__get (self) index))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/WebKitCSSFilterValue._get Mozilla WebKitCSSFilterValue._get documentation> 
+_getUnsafe ::
+           (MonadIO m, HasCallStack) =>
+             WebKitCSSFilterValue -> Word -> m CSSValue
+_getUnsafe self index
+  = liftIO
+      ((nullableToMaybe <$> (js__get (self) index)) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/WebKitCSSFilterValue._get Mozilla WebKitCSSFilterValue._get documentation> 
 _getUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/WebKitCSSMatrix.hs b/src/GHCJS/DOM/JSFFI/Generated/WebKitCSSMatrix.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/WebKitCSSMatrix.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/WebKitCSSMatrix.hs
@@ -1,29 +1,36 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.WebKitCSSMatrix
        (js_newWebKitCSSMatrix, newWebKitCSSMatrix, js_setMatrixValue,
-        setMatrixValue, js_multiply, multiply, multiply_,
-        multiplyUnchecked, js_inverse, inverse, inverse_, inverseUnchecked,
-        js_translate, translate, translate_, translateUnchecked, js_scale,
-        scale, scale_, scaleUnchecked, js_rotate, rotate, rotate_,
-        rotateUnchecked, js_rotateAxisAngle, rotateAxisAngle,
-        rotateAxisAngle_, rotateAxisAngleUnchecked, js_skewX, skewX,
-        skewX_, skewXUnchecked, js_skewY, skewY, skewY_, skewYUnchecked,
-        js_toString, toString, toString_, js_setA, setA, js_getA, getA,
-        js_setB, setB, js_getB, getB, js_setC, setC, js_getC, getC,
-        js_setD, setD, js_getD, getD, js_setE, setE, js_getE, getE,
-        js_setF, setF, js_getF, getF, js_setM11, setM11, js_getM11, getM11,
-        js_setM12, setM12, js_getM12, getM12, js_setM13, setM13, js_getM13,
-        getM13, js_setM14, setM14, js_getM14, getM14, js_setM21, setM21,
-        js_getM21, getM21, js_setM22, setM22, js_getM22, getM22, js_setM23,
-        setM23, js_getM23, getM23, js_setM24, setM24, js_getM24, getM24,
-        js_setM31, setM31, js_getM31, getM31, js_setM32, setM32, js_getM32,
-        getM32, js_setM33, setM33, js_getM33, getM33, js_setM34, setM34,
-        js_getM34, getM34, js_setM41, setM41, js_getM41, getM41, js_setM42,
-        setM42, js_getM42, getM42, js_setM43, setM43, js_getM43, getM43,
-        js_setM44, setM44, js_getM44, getM44, WebKitCSSMatrix,
-        castToWebKitCSSMatrix, gTypeWebKitCSSMatrix)
+        setMatrixValue, js_multiply, multiply, multiply_, multiplyUnsafe,
+        multiplyUnchecked, js_inverse, inverse, inverse_, inverseUnsafe,
+        inverseUnchecked, js_translate, translate, translate_,
+        translateUnsafe, translateUnchecked, js_scale, scale, scale_,
+        scaleUnsafe, scaleUnchecked, js_rotate, rotate, rotate_,
+        rotateUnsafe, rotateUnchecked, js_rotateAxisAngle, rotateAxisAngle,
+        rotateAxisAngle_, rotateAxisAngleUnsafe, rotateAxisAngleUnchecked,
+        js_skewX, skewX, skewX_, skewXUnsafe, skewXUnchecked, js_skewY,
+        skewY, skewY_, skewYUnsafe, skewYUnchecked, js_toString, toString,
+        toString_, js_setA, setA, js_getA, getA, js_setB, setB, js_getB,
+        getB, js_setC, setC, js_getC, getC, js_setD, setD, js_getD, getD,
+        js_setE, setE, js_getE, getE, js_setF, setF, js_getF, getF,
+        js_setM11, setM11, js_getM11, getM11, js_setM12, setM12, js_getM12,
+        getM12, js_setM13, setM13, js_getM13, getM13, js_setM14, setM14,
+        js_getM14, getM14, js_setM21, setM21, js_getM21, getM21, js_setM22,
+        setM22, js_getM22, getM22, js_setM23, setM23, js_getM23, getM23,
+        js_setM24, setM24, js_getM24, getM24, js_setM31, setM31, js_getM31,
+        getM31, js_setM32, setM32, js_getM32, getM32, js_setM33, setM33,
+        js_getM33, getM33, js_setM34, setM34, js_getM34, getM34, js_setM41,
+        setM41, js_getM41, getM41, js_setM42, setM42, js_getM42, getM42,
+        js_setM43, setM43, js_getM43, getM43, js_setM44, setM44, js_getM44,
+        getM44, WebKitCSSMatrix(..), gTypeWebKitCSSMatrix)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -39,6 +46,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe
         "new window[\"WebKitCSSMatrix\"]($1)" js_newWebKitCSSMatrix ::
@@ -81,6 +98,16 @@
   = liftIO (void (js_multiply (self) (maybeToNullable secondMatrix)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/WebKitCSSMatrix.multiply Mozilla WebKitCSSMatrix.multiply documentation> 
+multiplyUnsafe ::
+               (MonadIO m, HasCallStack) =>
+                 WebKitCSSMatrix -> Maybe WebKitCSSMatrix -> m WebKitCSSMatrix
+multiplyUnsafe self secondMatrix
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_multiply (self) (maybeToNullable secondMatrix)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/WebKitCSSMatrix.multiply Mozilla WebKitCSSMatrix.multiply documentation> 
 multiplyUnchecked ::
                   (MonadIO m) =>
                     WebKitCSSMatrix -> Maybe WebKitCSSMatrix -> m WebKitCSSMatrix
@@ -102,6 +129,14 @@
 inverse_ self = liftIO (void (js_inverse (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/WebKitCSSMatrix.inverse Mozilla WebKitCSSMatrix.inverse documentation> 
+inverseUnsafe ::
+              (MonadIO m, HasCallStack) => WebKitCSSMatrix -> m WebKitCSSMatrix
+inverseUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_inverse (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/WebKitCSSMatrix.inverse Mozilla WebKitCSSMatrix.inverse documentation> 
 inverseUnchecked ::
                  (MonadIO m) => WebKitCSSMatrix -> m WebKitCSSMatrix
 inverseUnchecked self
@@ -127,6 +162,15 @@
 translate_ self x y z = liftIO (void (js_translate (self) x y z))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/WebKitCSSMatrix.translate Mozilla WebKitCSSMatrix.translate documentation> 
+translateUnsafe ::
+                (MonadIO m, HasCallStack) =>
+                  WebKitCSSMatrix -> Double -> Double -> Double -> m WebKitCSSMatrix
+translateUnsafe self x y z
+  = liftIO
+      ((nullableToMaybe <$> (js_translate (self) x y z)) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/WebKitCSSMatrix.translate Mozilla WebKitCSSMatrix.translate documentation> 
 translateUnchecked ::
                    (MonadIO m) =>
                      WebKitCSSMatrix -> Double -> Double -> Double -> m WebKitCSSMatrix
@@ -156,6 +200,15 @@
   = liftIO (void (js_scale (self) scaleX scaleY scaleZ))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/WebKitCSSMatrix.scale Mozilla WebKitCSSMatrix.scale documentation> 
+scaleUnsafe ::
+            (MonadIO m, HasCallStack) =>
+              WebKitCSSMatrix -> Double -> Double -> Double -> m WebKitCSSMatrix
+scaleUnsafe self scaleX scaleY scaleZ
+  = liftIO
+      ((nullableToMaybe <$> (js_scale (self) scaleX scaleY scaleZ)) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/WebKitCSSMatrix.scale Mozilla WebKitCSSMatrix.scale documentation> 
 scaleUnchecked ::
                (MonadIO m) =>
                  WebKitCSSMatrix -> Double -> Double -> Double -> m WebKitCSSMatrix
@@ -185,6 +238,15 @@
   = liftIO (void (js_rotate (self) rotX rotY rotZ))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/WebKitCSSMatrix.rotate Mozilla WebKitCSSMatrix.rotate documentation> 
+rotateUnsafe ::
+             (MonadIO m, HasCallStack) =>
+               WebKitCSSMatrix -> Double -> Double -> Double -> m WebKitCSSMatrix
+rotateUnsafe self rotX rotY rotZ
+  = liftIO
+      ((nullableToMaybe <$> (js_rotate (self) rotX rotY rotZ)) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/WebKitCSSMatrix.rotate Mozilla WebKitCSSMatrix.rotate documentation> 
 rotateUnchecked ::
                 (MonadIO m) =>
                   WebKitCSSMatrix -> Double -> Double -> Double -> m WebKitCSSMatrix
@@ -215,6 +277,16 @@
   = liftIO (void (js_rotateAxisAngle (self) x y z angle))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/WebKitCSSMatrix.rotateAxisAngle Mozilla WebKitCSSMatrix.rotateAxisAngle documentation> 
+rotateAxisAngleUnsafe ::
+                      (MonadIO m, HasCallStack) =>
+                        WebKitCSSMatrix ->
+                          Double -> Double -> Double -> Double -> m WebKitCSSMatrix
+rotateAxisAngleUnsafe self x y z angle
+  = liftIO
+      ((nullableToMaybe <$> (js_rotateAxisAngle (self) x y z angle)) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/WebKitCSSMatrix.rotateAxisAngle Mozilla WebKitCSSMatrix.rotateAxisAngle documentation> 
 rotateAxisAngleUnchecked ::
                          (MonadIO m) =>
                            WebKitCSSMatrix ->
@@ -239,6 +311,15 @@
 skewX_ self angle = liftIO (void (js_skewX (self) angle))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/WebKitCSSMatrix.skewX Mozilla WebKitCSSMatrix.skewX documentation> 
+skewXUnsafe ::
+            (MonadIO m, HasCallStack) =>
+              WebKitCSSMatrix -> Double -> m WebKitCSSMatrix
+skewXUnsafe self angle
+  = liftIO
+      ((nullableToMaybe <$> (js_skewX (self) angle)) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/WebKitCSSMatrix.skewX Mozilla WebKitCSSMatrix.skewX documentation> 
 skewXUnchecked ::
                (MonadIO m) => WebKitCSSMatrix -> Double -> m WebKitCSSMatrix
 skewXUnchecked self angle
@@ -257,6 +338,15 @@
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/WebKitCSSMatrix.skewY Mozilla WebKitCSSMatrix.skewY documentation> 
 skewY_ :: (MonadIO m) => WebKitCSSMatrix -> Double -> m ()
 skewY_ self angle = liftIO (void (js_skewY (self) angle))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/WebKitCSSMatrix.skewY Mozilla WebKitCSSMatrix.skewY documentation> 
+skewYUnsafe ::
+            (MonadIO m, HasCallStack) =>
+              WebKitCSSMatrix -> Double -> m WebKitCSSMatrix
+skewYUnsafe self angle
+  = liftIO
+      ((nullableToMaybe <$> (js_skewY (self) angle)) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/WebKitCSSMatrix.skewY Mozilla WebKitCSSMatrix.skewY documentation> 
 skewYUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/WebKitCSSRegionRule.hs b/src/GHCJS/DOM/JSFFI/Generated/WebKitCSSRegionRule.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/WebKitCSSRegionRule.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/WebKitCSSRegionRule.hs
@@ -1,10 +1,16 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.WebKitCSSRegionRule
-       (js_getCssRules, getCssRules, getCssRulesUnchecked,
-        WebKitCSSRegionRule, castToWebKitCSSRegionRule,
+       (js_getCssRules, getCssRules, getCssRulesUnsafe,
+        getCssRulesUnchecked, WebKitCSSRegionRule(..),
         gTypeWebKitCSSRegionRule)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -20,6 +26,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"cssRules\"]" js_getCssRules
         :: WebKitCSSRegionRule -> IO (Nullable CSSRuleList)
@@ -29,6 +45,14 @@
             (MonadIO m) => WebKitCSSRegionRule -> m (Maybe CSSRuleList)
 getCssRules self
   = liftIO (nullableToMaybe <$> (js_getCssRules (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/WebKitCSSRegionRule.cssRules Mozilla WebKitCSSRegionRule.cssRules documentation> 
+getCssRulesUnsafe ::
+                  (MonadIO m, HasCallStack) => WebKitCSSRegionRule -> m CSSRuleList
+getCssRulesUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getCssRules (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/WebKitCSSRegionRule.cssRules Mozilla WebKitCSSRegionRule.cssRules documentation> 
 getCssRulesUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/WebKitCSSTransformValue.hs b/src/GHCJS/DOM/JSFFI/Generated/WebKitCSSTransformValue.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/WebKitCSSTransformValue.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/WebKitCSSTransformValue.hs
@@ -1,17 +1,24 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.WebKitCSSTransformValue
-       (js__get, _get, _get_, _getUnchecked, pattern CSS_TRANSLATE,
-        pattern CSS_TRANSLATEX, pattern CSS_TRANSLATEY, pattern CSS_ROTATE,
-        pattern CSS_SCALE, pattern CSS_SCALEX, pattern CSS_SCALEY,
-        pattern CSS_SKEW, pattern CSS_SKEWX, pattern CSS_SKEWY,
-        pattern CSS_MATRIX, pattern CSS_TRANSLATEZ,
-        pattern CSS_TRANSLATE3D, pattern CSS_ROTATEX, pattern CSS_ROTATEY,
-        pattern CSS_ROTATEZ, pattern CSS_ROTATE3D, pattern CSS_SCALEZ,
-        pattern CSS_SCALE3D, pattern CSS_PERSPECTIVE, pattern CSS_MATRIX3D,
-        js_getOperationType, getOperationType, WebKitCSSTransformValue,
-        castToWebKitCSSTransformValue, gTypeWebKitCSSTransformValue)
+       (js__get, _get, _get_, _getUnsafe, _getUnchecked,
+        pattern CSS_TRANSLATE, pattern CSS_TRANSLATEX,
+        pattern CSS_TRANSLATEY, pattern CSS_ROTATE, pattern CSS_SCALE,
+        pattern CSS_SCALEX, pattern CSS_SCALEY, pattern CSS_SKEW,
+        pattern CSS_SKEWX, pattern CSS_SKEWY, pattern CSS_MATRIX,
+        pattern CSS_TRANSLATEZ, pattern CSS_TRANSLATE3D,
+        pattern CSS_ROTATEX, pattern CSS_ROTATEY, pattern CSS_ROTATEZ,
+        pattern CSS_ROTATE3D, pattern CSS_SCALEZ, pattern CSS_SCALE3D,
+        pattern CSS_PERSPECTIVE, pattern CSS_MATRIX3D, js_getOperationType,
+        getOperationType, WebKitCSSTransformValue(..),
+        gTypeWebKitCSSTransformValue)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -27,6 +34,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"_get\"]($2)" js__get ::
         WebKitCSSTransformValue -> Word -> IO (Nullable CSSValue)
@@ -41,6 +58,15 @@
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/WebKitCSSTransformValue._get Mozilla WebKitCSSTransformValue._get documentation> 
 _get_ :: (MonadIO m) => WebKitCSSTransformValue -> Word -> m ()
 _get_ self index = liftIO (void (js__get (self) index))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/WebKitCSSTransformValue._get Mozilla WebKitCSSTransformValue._get documentation> 
+_getUnsafe ::
+           (MonadIO m, HasCallStack) =>
+             WebKitCSSTransformValue -> Word -> m CSSValue
+_getUnsafe self index
+  = liftIO
+      ((nullableToMaybe <$> (js__get (self) index)) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/WebKitCSSTransformValue._get Mozilla WebKitCSSTransformValue._get documentation> 
 _getUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/WebKitCSSViewportRule.hs b/src/GHCJS/DOM/JSFFI/Generated/WebKitCSSViewportRule.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/WebKitCSSViewportRule.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/WebKitCSSViewportRule.hs
@@ -1,9 +1,15 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.WebKitCSSViewportRule
-       (js_getStyle, getStyle, getStyleUnchecked, WebKitCSSViewportRule,
-        castToWebKitCSSViewportRule, gTypeWebKitCSSViewportRule)
+       (js_getStyle, getStyle, getStyleUnsafe, getStyleUnchecked,
+        WebKitCSSViewportRule(..), gTypeWebKitCSSViewportRule)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -19,6 +25,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"style\"]" js_getStyle ::
         WebKitCSSViewportRule -> IO (Nullable CSSStyleDeclaration)
@@ -28,6 +44,15 @@
          (MonadIO m) =>
            WebKitCSSViewportRule -> m (Maybe CSSStyleDeclaration)
 getStyle self = liftIO (nullableToMaybe <$> (js_getStyle (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/WebKitCSSViewportRule.style Mozilla WebKitCSSViewportRule.style documentation> 
+getStyleUnsafe ::
+               (MonadIO m, HasCallStack) =>
+                 WebKitCSSViewportRule -> m CSSStyleDeclaration
+getStyleUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getStyle (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/WebKitCSSViewportRule.style Mozilla WebKitCSSViewportRule.style documentation> 
 getStyleUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/WebKitNamedFlow.hs b/src/GHCJS/DOM/JSFFI/Generated/WebKitNamedFlow.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/WebKitNamedFlow.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/WebKitNamedFlow.hs
@@ -1,14 +1,21 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.WebKitNamedFlow
        (js_getRegionsByContent, getRegionsByContent, getRegionsByContent_,
-        getRegionsByContentUnchecked, js_getRegions, getRegions,
-        getRegions_, getRegionsUnchecked, js_getContent, getContent,
-        getContent_, getContentUnchecked, js_getName, getName,
+        getRegionsByContentUnsafe, getRegionsByContentUnchecked,
+        js_getRegions, getRegions, getRegions_, getRegionsUnsafe,
+        getRegionsUnchecked, js_getContent, getContent, getContent_,
+        getContentUnsafe, getContentUnchecked, js_getName, getName,
         js_getOverset, getOverset, js_getFirstEmptyRegionIndex,
-        getFirstEmptyRegionIndex, WebKitNamedFlow, castToWebKitNamedFlow,
+        getFirstEmptyRegionIndex, WebKitNamedFlow(..),
         gTypeWebKitNamedFlow)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -24,6 +31,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"getRegionsByContent\"]($2)"
         js_getRegionsByContent ::
@@ -50,6 +67,17 @@
             (maybeToNullable (fmap toNode contentNode))))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/WebKitNamedFlow.getRegionsByContent Mozilla WebKitNamedFlow.getRegionsByContent documentation> 
+getRegionsByContentUnsafe ::
+                          (MonadIO m, IsNode contentNode, HasCallStack) =>
+                            WebKitNamedFlow -> Maybe contentNode -> m NodeList
+getRegionsByContentUnsafe self contentNode
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_getRegionsByContent (self)
+             (maybeToNullable (fmap toNode contentNode))))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/WebKitNamedFlow.getRegionsByContent Mozilla WebKitNamedFlow.getRegionsByContent documentation> 
 getRegionsByContentUnchecked ::
                              (MonadIO m, IsNode contentNode) =>
                                WebKitNamedFlow -> Maybe contentNode -> m NodeList
@@ -72,6 +100,14 @@
 getRegions_ self = liftIO (void (js_getRegions (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/WebKitNamedFlow.getRegions Mozilla WebKitNamedFlow.getRegions documentation> 
+getRegionsUnsafe ::
+                 (MonadIO m, HasCallStack) => WebKitNamedFlow -> m NodeList
+getRegionsUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getRegions (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/WebKitNamedFlow.getRegions Mozilla WebKitNamedFlow.getRegions documentation> 
 getRegionsUnchecked :: (MonadIO m) => WebKitNamedFlow -> m NodeList
 getRegionsUnchecked self
   = liftIO (fromJust . nullableToMaybe <$> (js_getRegions (self)))
@@ -87,6 +123,14 @@
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/WebKitNamedFlow.getContent Mozilla WebKitNamedFlow.getContent documentation> 
 getContent_ :: (MonadIO m) => WebKitNamedFlow -> m ()
 getContent_ self = liftIO (void (js_getContent (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/WebKitNamedFlow.getContent Mozilla WebKitNamedFlow.getContent documentation> 
+getContentUnsafe ::
+                 (MonadIO m, HasCallStack) => WebKitNamedFlow -> m NodeList
+getContentUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getContent (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/WebKitNamedFlow.getContent Mozilla WebKitNamedFlow.getContent documentation> 
 getContentUnchecked :: (MonadIO m) => WebKitNamedFlow -> m NodeList
diff --git a/src/GHCJS/DOM/JSFFI/Generated/WebKitNamespace.hs b/src/GHCJS/DOM/JSFFI/Generated/WebKitNamespace.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/WebKitNamespace.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/WebKitNamespace.hs
@@ -1,10 +1,16 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.WebKitNamespace
        (js_getMessageHandlers, getMessageHandlers,
-        getMessageHandlersUnchecked, WebKitNamespace,
-        castToWebKitNamespace, gTypeWebKitNamespace)
+        getMessageHandlersUnsafe, getMessageHandlersUnchecked,
+        WebKitNamespace(..), gTypeWebKitNamespace)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -20,6 +26,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"messageHandlers\"]"
         js_getMessageHandlers ::
@@ -31,6 +47,15 @@
                      WebKitNamespace -> m (Maybe UserMessageHandlersNamespace)
 getMessageHandlers self
   = liftIO (nullableToMaybe <$> (js_getMessageHandlers (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/WebKitNamespace.messageHandlers Mozilla WebKitNamespace.messageHandlers documentation> 
+getMessageHandlersUnsafe ::
+                         (MonadIO m, HasCallStack) =>
+                           WebKitNamespace -> m UserMessageHandlersNamespace
+getMessageHandlersUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getMessageHandlers (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/WebKitNamespace.messageHandlers Mozilla WebKitNamespace.messageHandlers documentation> 
 getMessageHandlersUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/WebKitPlaybackTargetAvailabilityEvent.hs b/src/GHCJS/DOM/JSFFI/Generated/WebKitPlaybackTargetAvailabilityEvent.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/WebKitPlaybackTargetAvailabilityEvent.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/WebKitPlaybackTargetAvailabilityEvent.hs
@@ -1,11 +1,16 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.WebKitPlaybackTargetAvailabilityEvent
        (js_getAvailability, getAvailability,
-        WebKitPlaybackTargetAvailabilityEvent,
-        castToWebKitPlaybackTargetAvailabilityEvent,
+        WebKitPlaybackTargetAvailabilityEvent(..),
         gTypeWebKitPlaybackTargetAvailabilityEvent)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -21,6 +26,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"availability\"]"
         js_getAvailability ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/WebKitPoint.hs b/src/GHCJS/DOM/JSFFI/Generated/WebKitPoint.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/WebKitPoint.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/WebKitPoint.hs
@@ -1,10 +1,16 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.WebKitPoint
        (js_newWebKitPoint, newWebKitPoint, js_newWebKitPoint',
         newWebKitPoint', js_setX, setX, js_getX, getX, js_setY, setY,
-        js_getY, getY, WebKitPoint, castToWebKitPoint, gTypeWebKitPoint)
+        js_getY, getY, WebKitPoint(..), gTypeWebKitPoint)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -20,6 +26,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "new window[\"WebKitPoint\"]()"
         js_newWebKitPoint :: IO WebKitPoint
diff --git a/src/GHCJS/DOM/JSFFI/Generated/WebKitTransitionEvent.hs b/src/GHCJS/DOM/JSFFI/Generated/WebKitTransitionEvent.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/WebKitTransitionEvent.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/WebKitTransitionEvent.hs
@@ -1,11 +1,16 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.WebKitTransitionEvent
        (js_getPropertyName, getPropertyName, js_getElapsedTime,
         getElapsedTime, js_getPseudoElement, getPseudoElement,
-        WebKitTransitionEvent, castToWebKitTransitionEvent,
-        gTypeWebKitTransitionEvent)
+        WebKitTransitionEvent(..), gTypeWebKitTransitionEvent)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -21,6 +26,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"propertyName\"]"
         js_getPropertyName :: WebKitTransitionEvent -> IO JSString
diff --git a/src/GHCJS/DOM/JSFFI/Generated/WebSocket.hs b/src/GHCJS/DOM/JSFFI/Generated/WebSocket.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/WebSocket.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/WebSocket.hs
@@ -1,4 +1,9 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.WebSocket
        (js_newWebSocket, newWebSocket, js_newWebSocket', newWebSocket',
         js_send, send, js_sendView, sendView, js_sendBlob, sendBlob,
@@ -6,12 +11,14 @@
         pattern OPEN, pattern CLOSING, pattern CLOSED, js_getUrl, getUrl,
         js_getReadyState, getReadyState, js_getBufferedAmount,
         getBufferedAmount, open, message, error, closeEvent,
-        js_getProtocol, getProtocol, getProtocolUnchecked,
-        js_getExtensions, getExtensions, getExtensionsUnchecked,
-        js_setBinaryType, setBinaryType, js_getBinaryType, getBinaryType,
-        WebSocket, castToWebSocket, gTypeWebSocket)
+        js_getProtocol, getProtocol, getProtocolUnsafe,
+        getProtocolUnchecked, js_getExtensions, getExtensions,
+        getExtensionsUnsafe, getExtensionsUnchecked, js_setBinaryType,
+        setBinaryType, js_getBinaryType, getBinaryType, WebSocket(..),
+        gTypeWebSocket)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -27,6 +34,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe
         "new window[\"WebSocket\"]($1, $2)" js_newWebSocket ::
@@ -154,6 +171,15 @@
   = liftIO (fromMaybeJSString <$> (js_getProtocol (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/WebSocket.protocol Mozilla WebSocket.protocol documentation> 
+getProtocolUnsafe ::
+                  (MonadIO m, HasCallStack, FromJSString result) =>
+                    WebSocket -> m result
+getProtocolUnsafe self
+  = liftIO
+      ((fromMaybeJSString <$> (js_getProtocol (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/WebSocket.protocol Mozilla WebSocket.protocol documentation> 
 getProtocolUnchecked ::
                      (MonadIO m, FromJSString result) => WebSocket -> m result
 getProtocolUnchecked self
@@ -167,6 +193,15 @@
               (MonadIO m, FromJSString result) => WebSocket -> m (Maybe result)
 getExtensions self
   = liftIO (fromMaybeJSString <$> (js_getExtensions (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/WebSocket.extensions Mozilla WebSocket.extensions documentation> 
+getExtensionsUnsafe ::
+                    (MonadIO m, HasCallStack, FromJSString result) =>
+                      WebSocket -> m result
+getExtensionsUnsafe self
+  = liftIO
+      ((fromMaybeJSString <$> (js_getExtensions (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/WebSocket.extensions Mozilla WebSocket.extensions documentation> 
 getExtensionsUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/WheelEvent.hs b/src/GHCJS/DOM/JSFFI/Generated/WheelEvent.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/WheelEvent.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/WheelEvent.hs
@@ -1,4 +1,9 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.WheelEvent
        (js_initWebKitWheelEvent, initWebKitWheelEvent,
         pattern DOM_DELTA_PIXEL, pattern DOM_DELTA_LINE,
@@ -7,10 +12,11 @@
         js_getWheelDeltaX, getWheelDeltaX, js_getWheelDeltaY,
         getWheelDeltaY, js_getWheelDelta, getWheelDelta,
         js_getWebkitDirectionInvertedFromDevice,
-        getWebkitDirectionInvertedFromDevice, WheelEvent, castToWheelEvent,
+        getWebkitDirectionInvertedFromDevice, WheelEvent(..),
         gTypeWheelEvent)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -26,6 +32,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe
         "$1[\"initWebKitWheelEvent\"]($2,\n$3, $4, $5, $6, $7, $8, $9, $10,\n$11, $12)"
diff --git a/src/GHCJS/DOM/JSFFI/Generated/Window.hs b/src/GHCJS/DOM/JSFFI/Generated/Window.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/Window.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/Window.hs
@@ -1,25 +1,34 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.Window
-       (js_openDatabase, openDatabase, openDatabase_,
+       (js_openDatabase, openDatabase, openDatabase_, openDatabaseUnsafe,
         openDatabaseUnchecked, js_getSelection, getSelection,
-        getSelection_, getSelectionUnchecked, js_focus, focus, js_blur,
-        blur, js_close, close, js_print, print, js_stop, stop, js_open,
-        open, open_, openUnchecked, js_showModalDialog, showModalDialog,
-        showModalDialog_, js_alert, alert, js_confirm, confirm, confirm_,
-        js_prompt, prompt, prompt_, promptUnchecked, js_find, find, find_,
-        js_scrollBy, scrollBy, js_scrollTo, scrollTo, js_scroll, scroll,
-        js_moveBy, moveBy, js_moveTo, moveTo, js_resizeBy, resizeBy,
-        js_resizeTo, resizeTo, js_matchMedia, matchMedia, matchMedia_,
+        getSelection_, getSelectionUnsafe, getSelectionUnchecked, js_focus,
+        focus, js_blur, blur, js_close, close, js_print, print, js_stop,
+        stop, js_open, open, open_, openUnsafe, openUnchecked,
+        js_showModalDialog, showModalDialog, showModalDialog_, js_alert,
+        alert, js_confirm, confirm, confirm_, js_prompt, prompt, prompt_,
+        promptUnsafe, promptUnchecked, js_find, find, find_, js_scrollBy,
+        scrollBy, js_scrollTo, scrollTo, js_scroll, scroll, js_moveBy,
+        moveBy, js_moveTo, moveTo, js_resizeBy, resizeBy, js_resizeTo,
+        resizeTo, js_matchMedia, matchMedia, matchMedia_, matchMediaUnsafe,
         matchMediaUnchecked, js_getComputedStyle, getComputedStyle,
-        getComputedStyle_, getComputedStyleUnchecked,
-        js_getMatchedCSSRules, getMatchedCSSRules, getMatchedCSSRules_,
+        getComputedStyle_, getComputedStyleUnsafe,
+        getComputedStyleUnchecked, js_getMatchedCSSRules,
+        getMatchedCSSRules, getMatchedCSSRules_, getMatchedCSSRulesUnsafe,
         getMatchedCSSRulesUnchecked, js_webkitConvertPointFromPageToNode,
         webkitConvertPointFromPageToNode,
         webkitConvertPointFromPageToNode_,
+        webkitConvertPointFromPageToNodeUnsafe,
         webkitConvertPointFromPageToNodeUnchecked,
         js_webkitConvertPointFromNodeToPage,
         webkitConvertPointFromNodeToPage,
         webkitConvertPointFromNodeToPage_,
+        webkitConvertPointFromNodeToPageUnsafe,
         webkitConvertPointFromNodeToPageUnchecked, js_postMessage,
         postMessage, js_requestAnimationFrame, requestAnimationFrame,
         requestAnimationFrame_, js_cancelAnimationFrame,
@@ -29,69 +38,81 @@
         js_webkitCancelRequestAnimationFrame,
         webkitCancelRequestAnimationFrame, js_captureEvents, captureEvents,
         js_releaseEvents, releaseEvents, js_getWebkitIndexedDB,
-        getWebkitIndexedDB, getWebkitIndexedDBUnchecked, js_getIndexedDB,
-        getIndexedDB, getIndexedDBUnchecked, js_getWebkitStorageInfo,
-        getWebkitStorageInfo, getWebkitStorageInfoUnchecked,
-        js_getSpeechSynthesis, getSpeechSynthesis,
+        getWebkitIndexedDB, getWebkitIndexedDBUnsafe,
+        getWebkitIndexedDBUnchecked, js_getIndexedDB, getIndexedDB,
+        getIndexedDBUnsafe, getIndexedDBUnchecked, js_getWebkitStorageInfo,
+        getWebkitStorageInfo, getWebkitStorageInfoUnsafe,
+        getWebkitStorageInfoUnchecked, js_getSpeechSynthesis,
+        getSpeechSynthesis, getSpeechSynthesisUnsafe,
         getSpeechSynthesisUnchecked, js_getScreen, getScreen,
-        getScreenUnchecked, js_getHistory, getHistory, getHistoryUnchecked,
-        js_getLocationbar, getLocationbar, getLocationbarUnchecked,
-        js_getMenubar, getMenubar, getMenubarUnchecked, js_getPersonalbar,
-        getPersonalbar, getPersonalbarUnchecked, js_getScrollbars,
-        getScrollbars, getScrollbarsUnchecked, js_getStatusbar,
-        getStatusbar, getStatusbarUnchecked, js_getToolbar, getToolbar,
-        getToolbarUnchecked, js_getNavigator, getNavigator,
+        getScreenUnsafe, getScreenUnchecked, js_getHistory, getHistory,
+        getHistoryUnsafe, getHistoryUnchecked, js_getLocationbar,
+        getLocationbar, getLocationbarUnsafe, getLocationbarUnchecked,
+        js_getMenubar, getMenubar, getMenubarUnsafe, getMenubarUnchecked,
+        js_getPersonalbar, getPersonalbar, getPersonalbarUnsafe,
+        getPersonalbarUnchecked, js_getScrollbars, getScrollbars,
+        getScrollbarsUnsafe, getScrollbarsUnchecked, js_getStatusbar,
+        getStatusbar, getStatusbarUnsafe, getStatusbarUnchecked,
+        js_getToolbar, getToolbar, getToolbarUnsafe, getToolbarUnchecked,
+        js_getNavigator, getNavigator, getNavigatorUnsafe,
         getNavigatorUnchecked, js_getClientInformation,
-        getClientInformation, getClientInformationUnchecked, js_getCrypto,
-        getCrypto, getCryptoUnchecked, js_setLocation, setLocation,
-        js_getLocation, getLocation, getLocationUnchecked, js_getEvent,
-        getEvent, getEventUnchecked, js_getFrameElement, getFrameElement,
-        getFrameElementUnchecked, js_getOffscreenBuffering,
-        getOffscreenBuffering, js_getOuterHeight, getOuterHeight,
-        js_getOuterWidth, getOuterWidth, js_getInnerHeight, getInnerHeight,
-        js_getInnerWidth, getInnerWidth, js_getScreenX, getScreenX,
-        js_getScreenY, getScreenY, js_getScreenLeft, getScreenLeft,
-        js_getScreenTop, getScreenTop, js_getScrollX, getScrollX,
-        js_getScrollY, getScrollY, js_getPageXOffset, getPageXOffset,
-        js_getPageYOffset, getPageYOffset, js_getClosed, getClosed,
-        js_getLength, getLength, js_setName, setName, js_getName, getName,
-        js_setStatus, setStatus, js_getStatus, getStatus,
-        js_setDefaultStatus, setDefaultStatus, js_getDefaultStatus,
-        getDefaultStatus, js_setDefaultstatus, setDefaultstatus,
-        js_getDefaultstatus, getDefaultstatus, js_getSelf, getSelf,
-        getSelfUnchecked, js_getWindow, getWindow, getWindowUnchecked,
-        js_getFrames, getFrames, getFramesUnchecked, js_getOpener,
-        getOpener, getOpenerUnchecked, js_getParent, getParent,
-        getParentUnchecked, js_getTop, getTop, getTopUnchecked,
-        js_getDocument, getDocument, getDocumentUnchecked,
-        js_getStyleMedia, getStyleMedia, getStyleMediaUnchecked,
+        getClientInformation, getClientInformationUnsafe,
+        getClientInformationUnchecked, js_getCrypto, getCrypto,
+        getCryptoUnsafe, getCryptoUnchecked, js_setLocation, setLocation,
+        js_getLocation, getLocation, getLocationUnsafe,
+        getLocationUnchecked, js_getEvent, getEvent, getEventUnsafe,
+        getEventUnchecked, js_getFrameElement, getFrameElement,
+        getFrameElementUnsafe, getFrameElementUnchecked,
+        js_getOffscreenBuffering, getOffscreenBuffering, js_getOuterHeight,
+        getOuterHeight, js_getOuterWidth, getOuterWidth, js_getInnerHeight,
+        getInnerHeight, js_getInnerWidth, getInnerWidth, js_getScreenX,
+        getScreenX, js_getScreenY, getScreenY, js_getScreenLeft,
+        getScreenLeft, js_getScreenTop, getScreenTop, js_getScrollX,
+        getScrollX, js_getScrollY, getScrollY, js_getPageXOffset,
+        getPageXOffset, js_getPageYOffset, getPageYOffset, js_getClosed,
+        getClosed, js_getLength, getLength, js_setName, setName,
+        js_getName, getName, js_setStatus, setStatus, js_getStatus,
+        getStatus, js_setDefaultStatus, setDefaultStatus,
+        js_getDefaultStatus, getDefaultStatus, js_setDefaultstatus,
+        setDefaultstatus, js_getDefaultstatus, getDefaultstatus,
+        js_getSelf, getSelf, getSelfUnsafe, getSelfUnchecked, js_getWindow,
+        getWindow, getWindowUnsafe, getWindowUnchecked, js_getFrames,
+        getFrames, getFramesUnsafe, getFramesUnchecked, js_getOpener,
+        getOpener, getOpenerUnsafe, getOpenerUnchecked, js_getParent,
+        getParent, getParentUnsafe, getParentUnchecked, js_getTop, getTop,
+        getTopUnsafe, getTopUnchecked, js_getDocument, getDocument,
+        getDocumentUnsafe, getDocumentUnchecked, js_getStyleMedia,
+        getStyleMedia, getStyleMediaUnsafe, getStyleMediaUnchecked,
         js_getDevicePixelRatio, getDevicePixelRatio,
         js_getApplicationCache, getApplicationCache,
-        getApplicationCacheUnchecked, js_getSessionStorage,
-        getSessionStorage, getSessionStorageUnchecked, js_getLocalStorage,
-        getLocalStorage, getLocalStorageUnchecked, js_getOrientation,
+        getApplicationCacheUnsafe, getApplicationCacheUnchecked,
+        js_getSessionStorage, getSessionStorage, getSessionStorageUnsafe,
+        getSessionStorageUnchecked, js_getLocalStorage, getLocalStorage,
+        getLocalStorageUnsafe, getLocalStorageUnchecked, js_getOrientation,
         getOrientation, js_getPerformance, getPerformance,
-        getPerformanceUnchecked, js_getCSS, getCSS, getCSSUnchecked, abort,
-        beforeUnload, blurEvent, canPlay, canPlayThrough, change, click,
-        contextMenu, dblClick, drag, dragEnd, dragEnter, dragLeave,
-        dragOver, dragStart, drop, durationChange, emptied, ended, error,
-        focusEvent, hashChange, input, invalid, keyDown, keyPress, keyUp,
-        load, loadedData, loadedMetadata, loadStart, message, mouseDown,
-        mouseEnter, mouseLeave, mouseMove, mouseOut, mouseOver, mouseUp,
-        mouseWheel, offline, online, pageHide, pageShow, pause, play,
-        playing, popState, progress, rateChange, resize, scrollEvent,
-        seeked, seeking, select, stalled, storage, submit, suspend,
-        timeUpdate, unload, volumeChange, waiting, wheel, reset, search,
+        getPerformanceUnsafe, getPerformanceUnchecked, js_getCSS, getCSS,
+        getCSSUnsafe, getCSSUnchecked, abort, beforeUnload, blurEvent,
+        canPlay, canPlayThrough, change, click, contextMenu, dblClick,
+        drag, dragEnd, dragEnter, dragLeave, dragOver, dragStart, drop,
+        durationChange, emptied, ended, error, focusEvent, hashChange,
+        input, invalid, keyDown, keyPress, keyUp, load, loadedData,
+        loadedMetadata, loadStart, message, mouseDown, mouseEnter,
+        mouseLeave, mouseMove, mouseOut, mouseOver, mouseUp, mouseWheel,
+        offline, online, pageHide, pageShow, pause, play, playing,
+        popState, progress, rateChange, resize, scrollEvent, seeked,
+        seeking, select, stalled, storage, submit, suspend, timeUpdate,
+        unload, volumeChange, waiting, wheel, reset, search,
         webKitAnimationEnd, webKitAnimationIteration, webKitAnimationStart,
         animationEnd, animationIteration, animationStart,
         webKitTransitionEnd, transitionEnd, orientationChange, touchStart,
         touchMove, touchEnd, touchCancel, gestureStart, gestureChange,
         gestureEnd, deviceMotion, deviceOrientation, webKitDeviceProximity,
         webKitWillRevealBottom, webKitWillRevealLeft,
-        webKitWillRevealRight, webKitWillRevealTop, Window, castToWindow,
+        webKitWillRevealRight, webKitWillRevealTop, Window(..),
         gTypeWindow)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -107,6 +128,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe
         "$1[\"openDatabase\"]($2, $3, $4,\n$5, $6)" js_openDatabase ::
@@ -150,6 +181,24 @@
             (maybeToNullable creationCallback)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.openDatabase Mozilla Window.openDatabase documentation> 
+openDatabaseUnsafe ::
+                   (MonadIO m, ToJSString name, ToJSString version,
+                    ToJSString displayName, HasCallStack) =>
+                     Window ->
+                       name ->
+                         version ->
+                           displayName -> Word -> Maybe DatabaseCallback -> m Database
+openDatabaseUnsafe self name version displayName estimatedSize
+  creationCallback
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_openDatabase (self) (toJSString name) (toJSString version)
+             (toJSString displayName)
+             estimatedSize
+             (maybeToNullable creationCallback)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.openDatabase Mozilla Window.openDatabase documentation> 
 openDatabaseUnchecked ::
                       (MonadIO m, ToJSString name, ToJSString version,
                        ToJSString displayName) =>
@@ -179,6 +228,14 @@
 getSelection_ self = liftIO (void (js_getSelection (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.getSelection Mozilla Window.getSelection documentation> 
+getSelectionUnsafe ::
+                   (MonadIO m, HasCallStack) => Window -> m Selection
+getSelectionUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getSelection (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.getSelection Mozilla Window.getSelection documentation> 
 getSelectionUnchecked :: (MonadIO m) => Window -> m Selection
 getSelectionUnchecked self
   = liftIO (fromJust . nullableToMaybe <$> (js_getSelection (self)))
@@ -243,6 +300,18 @@
             (toJSString options)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.open Mozilla Window.open documentation> 
+openUnsafe ::
+           (MonadIO m, ToJSString url, ToJSString name, ToJSString options,
+            HasCallStack) =>
+             Window -> url -> name -> options -> m Window
+openUnsafe self url name options
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_open (self) (toJSString url) (toJSString name)
+             (toJSString options)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.open Mozilla Window.open documentation> 
 openUnchecked ::
               (MonadIO m, ToJSString url, ToJSString name, ToJSString options) =>
                 Window -> url -> name -> options -> m Window
@@ -324,6 +393,18 @@
             (toMaybeJSString defaultValue)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.prompt Mozilla Window.prompt documentation> 
+promptUnsafe ::
+             (MonadIO m, ToJSString message, ToJSString defaultValue,
+              HasCallStack, FromJSString result) =>
+               Window -> message -> Maybe defaultValue -> m result
+promptUnsafe self message defaultValue
+  = liftIO
+      ((fromMaybeJSString <$>
+          (js_prompt (self) (toJSString message)
+             (toMaybeJSString defaultValue)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.prompt Mozilla Window.prompt documentation> 
 promptUnchecked ::
                 (MonadIO m, ToJSString message, ToJSString defaultValue,
                  FromJSString result) =>
@@ -434,6 +515,15 @@
   = liftIO (void (js_matchMedia (self) (toJSString query)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.matchMedia Mozilla Window.matchMedia documentation> 
+matchMediaUnsafe ::
+                 (MonadIO m, ToJSString query, HasCallStack) =>
+                   Window -> query -> m MediaQueryList
+matchMediaUnsafe self query
+  = liftIO
+      ((nullableToMaybe <$> (js_matchMedia (self) (toJSString query)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.matchMedia Mozilla Window.matchMedia documentation> 
 matchMediaUnchecked ::
                     (MonadIO m, ToJSString query) =>
                       Window -> query -> m MediaQueryList
@@ -473,6 +563,20 @@
             (toMaybeJSString pseudoElement)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.getComputedStyle Mozilla Window.getComputedStyle documentation> 
+getComputedStyleUnsafe ::
+                       (MonadIO m, IsElement element, ToJSString pseudoElement,
+                        HasCallStack) =>
+                         Window ->
+                           Maybe element -> Maybe pseudoElement -> m CSSStyleDeclaration
+getComputedStyleUnsafe self element pseudoElement
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_getComputedStyle (self)
+             (maybeToNullable (fmap toElement element))
+             (toMaybeJSString pseudoElement)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.getComputedStyle Mozilla Window.getComputedStyle documentation> 
 getComputedStyleUnchecked ::
                           (MonadIO m, IsElement element, ToJSString pseudoElement) =>
                             Window ->
@@ -513,6 +617,19 @@
             (toMaybeJSString pseudoElement)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.getMatchedCSSRules Mozilla Window.getMatchedCSSRules documentation> 
+getMatchedCSSRulesUnsafe ::
+                         (MonadIO m, IsElement element, ToJSString pseudoElement,
+                          HasCallStack) =>
+                           Window -> Maybe element -> Maybe pseudoElement -> m CSSRuleList
+getMatchedCSSRulesUnsafe self element pseudoElement
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_getMatchedCSSRules (self)
+             (maybeToNullable (fmap toElement element))
+             (toMaybeJSString pseudoElement)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.getMatchedCSSRules Mozilla Window.getMatchedCSSRules documentation> 
 getMatchedCSSRulesUnchecked ::
                             (MonadIO m, IsElement element, ToJSString pseudoElement) =>
                               Window -> Maybe element -> Maybe pseudoElement -> m CSSRuleList
@@ -553,6 +670,18 @@
             (maybeToNullable p)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.webkitConvertPointFromPageToNode Mozilla Window.webkitConvertPointFromPageToNode documentation> 
+webkitConvertPointFromPageToNodeUnsafe ::
+                                       (MonadIO m, IsNode node, HasCallStack) =>
+                                         Window -> Maybe node -> Maybe WebKitPoint -> m WebKitPoint
+webkitConvertPointFromPageToNodeUnsafe self node p
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_webkitConvertPointFromPageToNode (self)
+             (maybeToNullable (fmap toNode node))
+             (maybeToNullable p)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.webkitConvertPointFromPageToNode Mozilla Window.webkitConvertPointFromPageToNode documentation> 
 webkitConvertPointFromPageToNodeUnchecked ::
                                           (MonadIO m, IsNode node) =>
                                             Window ->
@@ -594,6 +723,18 @@
             (maybeToNullable p)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.webkitConvertPointFromNodeToPage Mozilla Window.webkitConvertPointFromNodeToPage documentation> 
+webkitConvertPointFromNodeToPageUnsafe ::
+                                       (MonadIO m, IsNode node, HasCallStack) =>
+                                         Window -> Maybe node -> Maybe WebKitPoint -> m WebKitPoint
+webkitConvertPointFromNodeToPageUnsafe self node p
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_webkitConvertPointFromNodeToPage (self)
+             (maybeToNullable (fmap toNode node))
+             (maybeToNullable p)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.webkitConvertPointFromNodeToPage Mozilla Window.webkitConvertPointFromNodeToPage documentation> 
 webkitConvertPointFromNodeToPageUnchecked ::
                                           (MonadIO m, IsNode node) =>
                                             Window ->
@@ -716,6 +857,14 @@
   = liftIO (nullableToMaybe <$> (js_getWebkitIndexedDB (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.webkitIndexedDB Mozilla Window.webkitIndexedDB documentation> 
+getWebkitIndexedDBUnsafe ::
+                         (MonadIO m, HasCallStack) => Window -> m IDBFactory
+getWebkitIndexedDBUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getWebkitIndexedDB (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.webkitIndexedDB Mozilla Window.webkitIndexedDB documentation> 
 getWebkitIndexedDBUnchecked ::
                             (MonadIO m) => Window -> m IDBFactory
 getWebkitIndexedDBUnchecked self
@@ -731,6 +880,14 @@
   = liftIO (nullableToMaybe <$> (js_getIndexedDB (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.indexedDB Mozilla Window.indexedDB documentation> 
+getIndexedDBUnsafe ::
+                   (MonadIO m, HasCallStack) => Window -> m IDBFactory
+getIndexedDBUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getIndexedDB (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.indexedDB Mozilla Window.indexedDB documentation> 
 getIndexedDBUnchecked :: (MonadIO m) => Window -> m IDBFactory
 getIndexedDBUnchecked self
   = liftIO (fromJust . nullableToMaybe <$> (js_getIndexedDB (self)))
@@ -745,6 +902,14 @@
   = liftIO (nullableToMaybe <$> (js_getWebkitStorageInfo (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.webkitStorageInfo Mozilla Window.webkitStorageInfo documentation> 
+getWebkitStorageInfoUnsafe ::
+                           (MonadIO m, HasCallStack) => Window -> m StorageInfo
+getWebkitStorageInfoUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getWebkitStorageInfo (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.webkitStorageInfo Mozilla Window.webkitStorageInfo documentation> 
 getWebkitStorageInfoUnchecked ::
                               (MonadIO m) => Window -> m StorageInfo
 getWebkitStorageInfoUnchecked self
@@ -761,6 +926,14 @@
   = liftIO (nullableToMaybe <$> (js_getSpeechSynthesis (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.speechSynthesis Mozilla Window.speechSynthesis documentation> 
+getSpeechSynthesisUnsafe ::
+                         (MonadIO m, HasCallStack) => Window -> m SpeechSynthesis
+getSpeechSynthesisUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getSpeechSynthesis (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.speechSynthesis Mozilla Window.speechSynthesis documentation> 
 getSpeechSynthesisUnchecked ::
                             (MonadIO m) => Window -> m SpeechSynthesis
 getSpeechSynthesisUnchecked self
@@ -775,6 +948,13 @@
 getScreen self = liftIO (nullableToMaybe <$> (js_getScreen (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.screen Mozilla Window.screen documentation> 
+getScreenUnsafe :: (MonadIO m, HasCallStack) => Window -> m Screen
+getScreenUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getScreen (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.screen Mozilla Window.screen documentation> 
 getScreenUnchecked :: (MonadIO m) => Window -> m Screen
 getScreenUnchecked self
   = liftIO (fromJust . nullableToMaybe <$> (js_getScreen (self)))
@@ -788,6 +968,14 @@
   = liftIO (nullableToMaybe <$> (js_getHistory (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.history Mozilla Window.history documentation> 
+getHistoryUnsafe ::
+                 (MonadIO m, HasCallStack) => Window -> m History
+getHistoryUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getHistory (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.history Mozilla Window.history documentation> 
 getHistoryUnchecked :: (MonadIO m) => Window -> m History
 getHistoryUnchecked self
   = liftIO (fromJust . nullableToMaybe <$> (js_getHistory (self)))
@@ -801,6 +989,14 @@
   = liftIO (nullableToMaybe <$> (js_getLocationbar (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.locationbar Mozilla Window.locationbar documentation> 
+getLocationbarUnsafe ::
+                     (MonadIO m, HasCallStack) => Window -> m BarProp
+getLocationbarUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getLocationbar (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.locationbar Mozilla Window.locationbar documentation> 
 getLocationbarUnchecked :: (MonadIO m) => Window -> m BarProp
 getLocationbarUnchecked self
   = liftIO
@@ -815,6 +1011,14 @@
   = liftIO (nullableToMaybe <$> (js_getMenubar (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.menubar Mozilla Window.menubar documentation> 
+getMenubarUnsafe ::
+                 (MonadIO m, HasCallStack) => Window -> m BarProp
+getMenubarUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getMenubar (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.menubar Mozilla Window.menubar documentation> 
 getMenubarUnchecked :: (MonadIO m) => Window -> m BarProp
 getMenubarUnchecked self
   = liftIO (fromJust . nullableToMaybe <$> (js_getMenubar (self)))
@@ -828,6 +1032,14 @@
   = liftIO (nullableToMaybe <$> (js_getPersonalbar (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.personalbar Mozilla Window.personalbar documentation> 
+getPersonalbarUnsafe ::
+                     (MonadIO m, HasCallStack) => Window -> m BarProp
+getPersonalbarUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getPersonalbar (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.personalbar Mozilla Window.personalbar documentation> 
 getPersonalbarUnchecked :: (MonadIO m) => Window -> m BarProp
 getPersonalbarUnchecked self
   = liftIO
@@ -842,6 +1054,14 @@
   = liftIO (nullableToMaybe <$> (js_getScrollbars (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.scrollbars Mozilla Window.scrollbars documentation> 
+getScrollbarsUnsafe ::
+                    (MonadIO m, HasCallStack) => Window -> m BarProp
+getScrollbarsUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getScrollbars (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.scrollbars Mozilla Window.scrollbars documentation> 
 getScrollbarsUnchecked :: (MonadIO m) => Window -> m BarProp
 getScrollbarsUnchecked self
   = liftIO (fromJust . nullableToMaybe <$> (js_getScrollbars (self)))
@@ -855,6 +1075,14 @@
   = liftIO (nullableToMaybe <$> (js_getStatusbar (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.statusbar Mozilla Window.statusbar documentation> 
+getStatusbarUnsafe ::
+                   (MonadIO m, HasCallStack) => Window -> m BarProp
+getStatusbarUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getStatusbar (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.statusbar Mozilla Window.statusbar documentation> 
 getStatusbarUnchecked :: (MonadIO m) => Window -> m BarProp
 getStatusbarUnchecked self
   = liftIO (fromJust . nullableToMaybe <$> (js_getStatusbar (self)))
@@ -868,6 +1096,14 @@
   = liftIO (nullableToMaybe <$> (js_getToolbar (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.toolbar Mozilla Window.toolbar documentation> 
+getToolbarUnsafe ::
+                 (MonadIO m, HasCallStack) => Window -> m BarProp
+getToolbarUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getToolbar (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.toolbar Mozilla Window.toolbar documentation> 
 getToolbarUnchecked :: (MonadIO m) => Window -> m BarProp
 getToolbarUnchecked self
   = liftIO (fromJust . nullableToMaybe <$> (js_getToolbar (self)))
@@ -881,6 +1117,14 @@
   = liftIO (nullableToMaybe <$> (js_getNavigator (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.navigator Mozilla Window.navigator documentation> 
+getNavigatorUnsafe ::
+                   (MonadIO m, HasCallStack) => Window -> m Navigator
+getNavigatorUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getNavigator (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.navigator Mozilla Window.navigator documentation> 
 getNavigatorUnchecked :: (MonadIO m) => Window -> m Navigator
 getNavigatorUnchecked self
   = liftIO (fromJust . nullableToMaybe <$> (js_getNavigator (self)))
@@ -895,6 +1139,14 @@
   = liftIO (nullableToMaybe <$> (js_getClientInformation (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.clientInformation Mozilla Window.clientInformation documentation> 
+getClientInformationUnsafe ::
+                           (MonadIO m, HasCallStack) => Window -> m Navigator
+getClientInformationUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getClientInformation (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.clientInformation Mozilla Window.clientInformation documentation> 
 getClientInformationUnchecked ::
                               (MonadIO m) => Window -> m Navigator
 getClientInformationUnchecked self
@@ -909,6 +1161,13 @@
 getCrypto self = liftIO (nullableToMaybe <$> (js_getCrypto (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.crypto Mozilla Window.crypto documentation> 
+getCryptoUnsafe :: (MonadIO m, HasCallStack) => Window -> m Crypto
+getCryptoUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getCrypto (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.crypto Mozilla Window.crypto documentation> 
 getCryptoUnchecked :: (MonadIO m) => Window -> m Crypto
 getCryptoUnchecked self
   = liftIO (fromJust . nullableToMaybe <$> (js_getCrypto (self)))
@@ -930,6 +1189,14 @@
   = liftIO (nullableToMaybe <$> (js_getLocation (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.location Mozilla Window.location documentation> 
+getLocationUnsafe ::
+                  (MonadIO m, HasCallStack) => Window -> m Location
+getLocationUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getLocation (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.location Mozilla Window.location documentation> 
 getLocationUnchecked :: (MonadIO m) => Window -> m Location
 getLocationUnchecked self
   = liftIO (fromJust . nullableToMaybe <$> (js_getLocation (self)))
@@ -942,6 +1209,13 @@
 getEvent self = liftIO (nullableToMaybe <$> (js_getEvent (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.event Mozilla Window.event documentation> 
+getEventUnsafe :: (MonadIO m, HasCallStack) => Window -> m Event
+getEventUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getEvent (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.event Mozilla Window.event documentation> 
 getEventUnchecked :: (MonadIO m) => Window -> m Event
 getEventUnchecked self
   = liftIO (fromJust . nullableToMaybe <$> (js_getEvent (self)))
@@ -955,6 +1229,14 @@
   = liftIO (nullableToMaybe <$> (js_getFrameElement (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.frameElement Mozilla Window.frameElement documentation> 
+getFrameElementUnsafe ::
+                      (MonadIO m, HasCallStack) => Window -> m Element
+getFrameElementUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getFrameElement (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.frameElement Mozilla Window.frameElement documentation> 
 getFrameElementUnchecked :: (MonadIO m) => Window -> m Element
 getFrameElementUnchecked self
   = liftIO
@@ -1139,6 +1421,13 @@
 getSelf self = liftIO (nullableToMaybe <$> (js_getSelf (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.self Mozilla Window.self documentation> 
+getSelfUnsafe :: (MonadIO m, HasCallStack) => Window -> m Window
+getSelfUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getSelf (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.self Mozilla Window.self documentation> 
 getSelfUnchecked :: (MonadIO m) => Window -> m Window
 getSelfUnchecked self
   = liftIO (fromJust . nullableToMaybe <$> (js_getSelf (self)))
@@ -1151,6 +1440,13 @@
 getWindow self = liftIO (nullableToMaybe <$> (js_getWindow (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.window Mozilla Window.window documentation> 
+getWindowUnsafe :: (MonadIO m, HasCallStack) => Window -> m Window
+getWindowUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getWindow (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.window Mozilla Window.window documentation> 
 getWindowUnchecked :: (MonadIO m) => Window -> m Window
 getWindowUnchecked self
   = liftIO (fromJust . nullableToMaybe <$> (js_getWindow (self)))
@@ -1163,6 +1459,13 @@
 getFrames self = liftIO (nullableToMaybe <$> (js_getFrames (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.frames Mozilla Window.frames documentation> 
+getFramesUnsafe :: (MonadIO m, HasCallStack) => Window -> m Window
+getFramesUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getFrames (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.frames Mozilla Window.frames documentation> 
 getFramesUnchecked :: (MonadIO m) => Window -> m Window
 getFramesUnchecked self
   = liftIO (fromJust . nullableToMaybe <$> (js_getFrames (self)))
@@ -1175,6 +1478,13 @@
 getOpener self = liftIO (nullableToMaybe <$> (js_getOpener (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.opener Mozilla Window.opener documentation> 
+getOpenerUnsafe :: (MonadIO m, HasCallStack) => Window -> m Window
+getOpenerUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getOpener (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.opener Mozilla Window.opener documentation> 
 getOpenerUnchecked :: (MonadIO m) => Window -> m Window
 getOpenerUnchecked self
   = liftIO (fromJust . nullableToMaybe <$> (js_getOpener (self)))
@@ -1187,6 +1497,13 @@
 getParent self = liftIO (nullableToMaybe <$> (js_getParent (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.parent Mozilla Window.parent documentation> 
+getParentUnsafe :: (MonadIO m, HasCallStack) => Window -> m Window
+getParentUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getParent (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.parent Mozilla Window.parent documentation> 
 getParentUnchecked :: (MonadIO m) => Window -> m Window
 getParentUnchecked self
   = liftIO (fromJust . nullableToMaybe <$> (js_getParent (self)))
@@ -1199,6 +1516,13 @@
 getTop self = liftIO (nullableToMaybe <$> (js_getTop (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.top Mozilla Window.top documentation> 
+getTopUnsafe :: (MonadIO m, HasCallStack) => Window -> m Window
+getTopUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getTop (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.top Mozilla Window.top documentation> 
 getTopUnchecked :: (MonadIO m) => Window -> m Window
 getTopUnchecked self
   = liftIO (fromJust . nullableToMaybe <$> (js_getTop (self)))
@@ -1212,6 +1536,14 @@
   = liftIO (nullableToMaybe <$> (js_getDocument (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.document Mozilla Window.document documentation> 
+getDocumentUnsafe ::
+                  (MonadIO m, HasCallStack) => Window -> m Document
+getDocumentUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getDocument (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.document Mozilla Window.document documentation> 
 getDocumentUnchecked :: (MonadIO m) => Window -> m Document
 getDocumentUnchecked self
   = liftIO (fromJust . nullableToMaybe <$> (js_getDocument (self)))
@@ -1225,6 +1557,14 @@
   = liftIO (nullableToMaybe <$> (js_getStyleMedia (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.styleMedia Mozilla Window.styleMedia documentation> 
+getStyleMediaUnsafe ::
+                    (MonadIO m, HasCallStack) => Window -> m StyleMedia
+getStyleMediaUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getStyleMedia (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.styleMedia Mozilla Window.styleMedia documentation> 
 getStyleMediaUnchecked :: (MonadIO m) => Window -> m StyleMedia
 getStyleMediaUnchecked self
   = liftIO (fromJust . nullableToMaybe <$> (js_getStyleMedia (self)))
@@ -1246,6 +1586,14 @@
   = liftIO (nullableToMaybe <$> (js_getApplicationCache (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.applicationCache Mozilla Window.applicationCache documentation> 
+getApplicationCacheUnsafe ::
+                          (MonadIO m, HasCallStack) => Window -> m ApplicationCache
+getApplicationCacheUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getApplicationCache (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.applicationCache Mozilla Window.applicationCache documentation> 
 getApplicationCacheUnchecked ::
                              (MonadIO m) => Window -> m ApplicationCache
 getApplicationCacheUnchecked self
@@ -1261,6 +1609,14 @@
   = liftIO (nullableToMaybe <$> (js_getSessionStorage (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.sessionStorage Mozilla Window.sessionStorage documentation> 
+getSessionStorageUnsafe ::
+                        (MonadIO m, HasCallStack) => Window -> m Storage
+getSessionStorageUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getSessionStorage (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.sessionStorage Mozilla Window.sessionStorage documentation> 
 getSessionStorageUnchecked :: (MonadIO m) => Window -> m Storage
 getSessionStorageUnchecked self
   = liftIO
@@ -1275,6 +1631,14 @@
   = liftIO (nullableToMaybe <$> (js_getLocalStorage (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.localStorage Mozilla Window.localStorage documentation> 
+getLocalStorageUnsafe ::
+                      (MonadIO m, HasCallStack) => Window -> m Storage
+getLocalStorageUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getLocalStorage (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.localStorage Mozilla Window.localStorage documentation> 
 getLocalStorageUnchecked :: (MonadIO m) => Window -> m Storage
 getLocalStorageUnchecked self
   = liftIO
@@ -1296,6 +1660,14 @@
   = liftIO (nullableToMaybe <$> (js_getPerformance (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.performance Mozilla Window.performance documentation> 
+getPerformanceUnsafe ::
+                     (MonadIO m, HasCallStack) => Window -> m Performance
+getPerformanceUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getPerformance (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.performance Mozilla Window.performance documentation> 
 getPerformanceUnchecked :: (MonadIO m) => Window -> m Performance
 getPerformanceUnchecked self
   = liftIO
@@ -1307,6 +1679,13 @@
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.CSS Mozilla Window.CSS documentation> 
 getCSS :: (MonadIO m) => Window -> m (Maybe CSS)
 getCSS self = liftIO (nullableToMaybe <$> (js_getCSS (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.CSS Mozilla Window.CSS documentation> 
+getCSSUnsafe :: (MonadIO m, HasCallStack) => Window -> m CSS
+getCSSUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getCSS (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.CSS Mozilla Window.CSS documentation> 
 getCSSUnchecked :: (MonadIO m) => Window -> m CSS
diff --git a/src/GHCJS/DOM/JSFFI/Generated/WindowBase64.hs b/src/GHCJS/DOM/JSFFI/Generated/WindowBase64.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/WindowBase64.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/WindowBase64.hs
@@ -1,9 +1,15 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.WindowBase64
-       (js_atob, atob, atob_, js_btoa, btoa, btoa_, WindowBase64,
-        castToWindowBase64, gTypeWindowBase64)
+       (js_atob, atob, atob_, js_btoa, btoa, btoa_, WindowBase64(..),
+        gTypeWindowBase64)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -19,6 +25,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"atob\"]($2)" js_atob ::
         WindowBase64 -> JSString -> IO JSString
diff --git a/src/GHCJS/DOM/JSFFI/Generated/WindowTimers.hs b/src/GHCJS/DOM/JSFFI/Generated/WindowTimers.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/WindowTimers.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/WindowTimers.hs
@@ -1,11 +1,17 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.WindowTimers
        (js_setTimeout, setTimeout, setTimeout_, js_clearTimeout,
         clearTimeout, js_setInterval, setInterval, setInterval_,
-        js_clearInterval, clearInterval, WindowTimers, castToWindowTimers,
+        js_clearInterval, clearInterval, WindowTimers(..),
         gTypeWindowTimers)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -21,6 +27,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"setTimeout\"]($2, $3)"
         js_setTimeout :: WindowTimers -> JSVal -> Int -> IO Int
diff --git a/src/GHCJS/DOM/JSFFI/Generated/Worker.hs b/src/GHCJS/DOM/JSFFI/Generated/Worker.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/Worker.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/Worker.hs
@@ -1,10 +1,15 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.Worker
        (js_newWorker, newWorker, js_postMessage, postMessage,
-        js_terminate, terminate, message, Worker, castToWorker,
-        gTypeWorker)
+        js_terminate, terminate, message, Worker(..), gTypeWorker)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -20,6 +25,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "new window[\"Worker\"]($1)"
         js_newWorker :: JSString -> IO Worker
diff --git a/src/GHCJS/DOM/JSFFI/Generated/WorkerGlobalScope.hs b/src/GHCJS/DOM/JSFFI/Generated/WorkerGlobalScope.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/WorkerGlobalScope.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/WorkerGlobalScope.hs
@@ -1,13 +1,19 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.WorkerGlobalScope
        (js_close, close, js_importScripts, importScripts, js_getSelf,
-        getSelf, getSelfUnchecked, js_getLocation, getLocation,
-        getLocationUnchecked, error, offline, online, js_getNavigator,
-        getNavigator, getNavigatorUnchecked, WorkerGlobalScope,
-        castToWorkerGlobalScope, gTypeWorkerGlobalScope,
-        IsWorkerGlobalScope, toWorkerGlobalScope)
+        getSelf, getSelfUnsafe, getSelfUnchecked, js_getLocation,
+        getLocation, getLocationUnsafe, getLocationUnchecked, error,
+        offline, online, js_getNavigator, getNavigator, getNavigatorUnsafe,
+        getNavigatorUnchecked, WorkerGlobalScope(..),
+        gTypeWorkerGlobalScope, IsWorkerGlobalScope, toWorkerGlobalScope)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -23,6 +29,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"close\"]()" js_close ::
         WorkerGlobalScope -> IO ()
@@ -52,6 +68,15 @@
       (nullableToMaybe <$> (js_getSelf (toWorkerGlobalScope self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/WorkerGlobalScope.self Mozilla WorkerGlobalScope.self documentation> 
+getSelfUnsafe ::
+              (MonadIO m, IsWorkerGlobalScope self, HasCallStack) =>
+                self -> m WorkerGlobalScope
+getSelfUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getSelf (toWorkerGlobalScope self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/WorkerGlobalScope.self Mozilla WorkerGlobalScope.self documentation> 
 getSelfUnchecked ::
                  (MonadIO m, IsWorkerGlobalScope self) =>
                    self -> m WorkerGlobalScope
@@ -72,6 +97,15 @@
       (nullableToMaybe <$> (js_getLocation (toWorkerGlobalScope self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/WorkerGlobalScope.location Mozilla WorkerGlobalScope.location documentation> 
+getLocationUnsafe ::
+                  (MonadIO m, IsWorkerGlobalScope self, HasCallStack) =>
+                    self -> m WorkerLocation
+getLocationUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getLocation (toWorkerGlobalScope self)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/WorkerGlobalScope.location Mozilla WorkerGlobalScope.location documentation> 
 getLocationUnchecked ::
                      (MonadIO m, IsWorkerGlobalScope self) => self -> m WorkerLocation
 getLocationUnchecked self
@@ -108,6 +142,15 @@
 getNavigator self
   = liftIO
       (nullableToMaybe <$> (js_getNavigator (toWorkerGlobalScope self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/WorkerGlobalScope.navigator Mozilla WorkerGlobalScope.navigator documentation> 
+getNavigatorUnsafe ::
+                   (MonadIO m, IsWorkerGlobalScope self, HasCallStack) =>
+                     self -> m WorkerNavigator
+getNavigatorUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getNavigator (toWorkerGlobalScope self)))
+         >>= maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/WorkerGlobalScope.navigator Mozilla WorkerGlobalScope.navigator documentation> 
 getNavigatorUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/WorkerLocation.hs b/src/GHCJS/DOM/JSFFI/Generated/WorkerLocation.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/WorkerLocation.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/WorkerLocation.hs
@@ -1,12 +1,18 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.WorkerLocation
        (js_toString, toString, toString_, js_getHref, getHref,
         js_getProtocol, getProtocol, js_getHost, getHost, js_getHostname,
         getHostname, js_getPort, getPort, js_getPathname, getPathname,
-        js_getSearch, getSearch, js_getHash, getHash, WorkerLocation,
-        castToWorkerLocation, gTypeWorkerLocation)
+        js_getSearch, getSearch, js_getHash, getHash, WorkerLocation(..),
+        gTypeWorkerLocation)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -22,6 +28,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"toString\"]()" js_toString
         :: WorkerLocation -> IO JSString
diff --git a/src/GHCJS/DOM/JSFFI/Generated/WorkerNavigator.hs b/src/GHCJS/DOM/JSFFI/Generated/WorkerNavigator.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/WorkerNavigator.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/WorkerNavigator.hs
@@ -1,14 +1,21 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.WorkerNavigator
        (js_getWebkitTemporaryStorage, getWebkitTemporaryStorage,
+        getWebkitTemporaryStorageUnsafe,
         getWebkitTemporaryStorageUnchecked, js_getWebkitPersistentStorage,
-        getWebkitPersistentStorage, getWebkitPersistentStorageUnchecked,
-        js_getAppName, getAppName, js_getAppVersion, getAppVersion,
-        js_getPlatform, getPlatform, js_getUserAgent, getUserAgent,
-        js_getOnLine, getOnLine, WorkerNavigator, castToWorkerNavigator,
-        gTypeWorkerNavigator)
+        getWebkitPersistentStorage, getWebkitPersistentStorageUnsafe,
+        getWebkitPersistentStorageUnchecked, js_getAppName, getAppName,
+        js_getAppVersion, getAppVersion, js_getPlatform, getPlatform,
+        js_getUserAgent, getUserAgent, js_getOnLine, getOnLine,
+        WorkerNavigator(..), gTypeWorkerNavigator)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -24,6 +31,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"webkitTemporaryStorage\"]"
         js_getWebkitTemporaryStorage ::
@@ -37,6 +54,14 @@
       (nullableToMaybe <$> (js_getWebkitTemporaryStorage (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/WorkerNavigator.webkitTemporaryStorage Mozilla WorkerNavigator.webkitTemporaryStorage documentation> 
+getWebkitTemporaryStorageUnsafe ::
+                                (MonadIO m, HasCallStack) => WorkerNavigator -> m StorageQuota
+getWebkitTemporaryStorageUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getWebkitTemporaryStorage (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/WorkerNavigator.webkitTemporaryStorage Mozilla WorkerNavigator.webkitTemporaryStorage documentation> 
 getWebkitTemporaryStorageUnchecked ::
                                    (MonadIO m) => WorkerNavigator -> m StorageQuota
 getWebkitTemporaryStorageUnchecked self
@@ -54,6 +79,14 @@
 getWebkitPersistentStorage self
   = liftIO
       (nullableToMaybe <$> (js_getWebkitPersistentStorage (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/WorkerNavigator.webkitPersistentStorage Mozilla WorkerNavigator.webkitPersistentStorage documentation> 
+getWebkitPersistentStorageUnsafe ::
+                                 (MonadIO m, HasCallStack) => WorkerNavigator -> m StorageQuota
+getWebkitPersistentStorageUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getWebkitPersistentStorage (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/WorkerNavigator.webkitPersistentStorage Mozilla WorkerNavigator.webkitPersistentStorage documentation> 
 getWebkitPersistentStorageUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/XMLHttpRequest.hs b/src/GHCJS/DOM/JSFFI/Generated/XMLHttpRequest.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/XMLHttpRequest.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/XMLHttpRequest.hs
@@ -1,10 +1,16 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.XMLHttpRequest
        (js_newXMLHttpRequest, newXMLHttpRequest, js_open, open,
         js_setRequestHeader, setRequestHeader, js_send, send, js_abort,
         abort, js_getAllResponseHeaders, getAllResponseHeaders,
-        getAllResponseHeaders_, getAllResponseHeadersUnchecked,
-        js_getResponseHeader, getResponseHeader, getResponseHeader_,
+        getAllResponseHeaders_, getAllResponseHeadersUnsafe,
+        getAllResponseHeadersUnchecked, js_getResponseHeader,
+        getResponseHeader, getResponseHeader_, getResponseHeaderUnsafe,
         getResponseHeaderUnchecked, js_overrideMimeType, overrideMimeType,
         pattern UNSENT, pattern OPENED, pattern HEADERS_RECEIVED,
         pattern LOADING, pattern DONE, abortEvent, error, load, loadEnd,
@@ -12,15 +18,17 @@
         setTimeout, js_getTimeout, getTimeout, js_getReadyState,
         getReadyState, js_setWithCredentials, setWithCredentials,
         js_getWithCredentials, getWithCredentials, js_getUpload, getUpload,
-        getUploadUnchecked, js_getResponseText, getResponseText,
-        getResponseTextUnchecked, js_getResponseXML, getResponseXML,
+        getUploadUnsafe, getUploadUnchecked, js_getResponseText,
+        getResponseText, getResponseTextUnsafe, getResponseTextUnchecked,
+        js_getResponseXML, getResponseXML, getResponseXMLUnsafe,
         getResponseXMLUnchecked, js_setResponseType, setResponseType,
         js_getResponseType, getResponseType, js_getResponse, getResponse,
-        getResponseUnchecked, js_getStatus, getStatus, js_getStatusText,
-        getStatusText, js_getResponseURL, getResponseURL, XMLHttpRequest,
-        castToXMLHttpRequest, gTypeXMLHttpRequest)
+        getResponseUnsafe, getResponseUnchecked, js_getStatus, getStatus,
+        js_getStatusText, getStatusText, js_getResponseURL, getResponseURL,
+        XMLHttpRequest(..), gTypeXMLHttpRequest)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -36,6 +44,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "new window[\"XMLHttpRequest\"]()"
         js_newXMLHttpRequest :: IO XMLHttpRequest
@@ -103,6 +121,15 @@
   = liftIO (void (js_getAllResponseHeaders (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest.getAllResponseHeaders Mozilla XMLHttpRequest.getAllResponseHeaders documentation> 
+getAllResponseHeadersUnsafe ::
+                            (MonadIO m, HasCallStack, FromJSString result) =>
+                              XMLHttpRequest -> m result
+getAllResponseHeadersUnsafe self
+  = liftIO
+      ((fromMaybeJSString <$> (js_getAllResponseHeaders (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest.getAllResponseHeaders Mozilla XMLHttpRequest.getAllResponseHeaders documentation> 
 getAllResponseHeadersUnchecked ::
                                (MonadIO m, FromJSString result) => XMLHttpRequest -> m result
 getAllResponseHeadersUnchecked self
@@ -130,6 +157,17 @@
   = liftIO (void (js_getResponseHeader (self) (toJSString header)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest.getResponseHeader Mozilla XMLHttpRequest.getResponseHeader documentation> 
+getResponseHeaderUnsafe ::
+                        (MonadIO m, ToJSString header, HasCallStack,
+                         FromJSString result) =>
+                          XMLHttpRequest -> header -> m result
+getResponseHeaderUnsafe self header
+  = liftIO
+      ((fromMaybeJSString <$>
+          (js_getResponseHeader (self) (toJSString header)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest.getResponseHeader Mozilla XMLHttpRequest.getResponseHeader documentation> 
 getResponseHeaderUnchecked ::
                            (MonadIO m, ToJSString header, FromJSString result) =>
                              XMLHttpRequest -> header -> m result
@@ -231,6 +269,15 @@
 getUpload self = liftIO (nullableToMaybe <$> (js_getUpload (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest.upload Mozilla XMLHttpRequest.upload documentation> 
+getUploadUnsafe ::
+                (MonadIO m, HasCallStack) =>
+                  XMLHttpRequest -> m XMLHttpRequestUpload
+getUploadUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getUpload (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest.upload Mozilla XMLHttpRequest.upload documentation> 
 getUploadUnchecked ::
                    (MonadIO m) => XMLHttpRequest -> m XMLHttpRequestUpload
 getUploadUnchecked self
@@ -247,6 +294,15 @@
   = liftIO (fromMaybeJSString <$> (js_getResponseText (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest.responseText Mozilla XMLHttpRequest.responseText documentation> 
+getResponseTextUnsafe ::
+                      (MonadIO m, HasCallStack, FromJSString result) =>
+                        XMLHttpRequest -> m result
+getResponseTextUnsafe self
+  = liftIO
+      ((fromMaybeJSString <$> (js_getResponseText (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest.responseText Mozilla XMLHttpRequest.responseText documentation> 
 getResponseTextUnchecked ::
                          (MonadIO m, FromJSString result) => XMLHttpRequest -> m result
 getResponseTextUnchecked self
@@ -263,6 +319,14 @@
   = liftIO (nullableToMaybe <$> (js_getResponseXML (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest.responseXML Mozilla XMLHttpRequest.responseXML documentation> 
+getResponseXMLUnsafe ::
+                     (MonadIO m, HasCallStack) => XMLHttpRequest -> m Document
+getResponseXMLUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getResponseXML (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest.responseXML Mozilla XMLHttpRequest.responseXML documentation> 
 getResponseXMLUnchecked ::
                         (MonadIO m) => XMLHttpRequest -> m Document
 getResponseXMLUnchecked self
@@ -294,6 +358,14 @@
 getResponse :: (MonadIO m) => XMLHttpRequest -> m (Maybe GObject)
 getResponse self
   = liftIO (nullableToMaybe <$> (js_getResponse (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest.response Mozilla XMLHttpRequest.response documentation> 
+getResponseUnsafe ::
+                  (MonadIO m, HasCallStack) => XMLHttpRequest -> m GObject
+getResponseUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getResponse (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest.response Mozilla XMLHttpRequest.response documentation> 
 getResponseUnchecked :: (MonadIO m) => XMLHttpRequest -> m GObject
diff --git a/src/GHCJS/DOM/JSFFI/Generated/XMLHttpRequestProgressEvent.hs b/src/GHCJS/DOM/JSFFI/Generated/XMLHttpRequestProgressEvent.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/XMLHttpRequestProgressEvent.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/XMLHttpRequestProgressEvent.hs
@@ -1,10 +1,15 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.XMLHttpRequestProgressEvent
        (js_getPosition, getPosition, js_getTotalSize, getTotalSize,
-        XMLHttpRequestProgressEvent, castToXMLHttpRequestProgressEvent,
-        gTypeXMLHttpRequestProgressEvent)
+        XMLHttpRequestProgressEvent(..), gTypeXMLHttpRequestProgressEvent)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -20,6 +25,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"position\"]" js_getPosition
         :: XMLHttpRequestProgressEvent -> IO Double
diff --git a/src/GHCJS/DOM/JSFFI/Generated/XMLHttpRequestUpload.hs b/src/GHCJS/DOM/JSFFI/Generated/XMLHttpRequestUpload.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/XMLHttpRequestUpload.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/XMLHttpRequestUpload.hs
@@ -1,10 +1,15 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.XMLHttpRequestUpload
        (abort, error, load, loadEnd, loadStart, progress,
-        XMLHttpRequestUpload, castToXMLHttpRequestUpload,
-        gTypeXMLHttpRequestUpload)
+        XMLHttpRequestUpload(..), gTypeXMLHttpRequestUpload)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -20,6 +25,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequestUpload.onabort Mozilla XMLHttpRequestUpload.onabort documentation> 
 abort :: EventName XMLHttpRequestUpload XMLHttpRequestProgressEvent
diff --git a/src/GHCJS/DOM/JSFFI/Generated/XMLSerializer.hs b/src/GHCJS/DOM/JSFFI/Generated/XMLSerializer.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/XMLSerializer.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/XMLSerializer.hs
@@ -1,10 +1,16 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.XMLSerializer
        (js_newXMLSerializer, newXMLSerializer, js_serializeToString,
-        serializeToString, serializeToString_, XMLSerializer,
-        castToXMLSerializer, gTypeXMLSerializer)
+        serializeToString, serializeToString_, XMLSerializer(..),
+        gTypeXMLSerializer)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -20,6 +26,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "new window[\"XMLSerializer\"]()"
         js_newXMLSerializer :: IO XMLSerializer
diff --git a/src/GHCJS/DOM/JSFFI/Generated/XPathEvaluator.hs b/src/GHCJS/DOM/JSFFI/Generated/XPathEvaluator.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/XPathEvaluator.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/XPathEvaluator.hs
@@ -1,13 +1,20 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.XPathEvaluator
        (js_newXPathEvaluator, newXPathEvaluator, js_createExpression,
-        createExpression, createExpression_, createExpressionUnchecked,
-        js_createNSResolver, createNSResolver, createNSResolver_,
+        createExpression, createExpression_, createExpressionUnsafe,
+        createExpressionUnchecked, js_createNSResolver, createNSResolver,
+        createNSResolver_, createNSResolverUnsafe,
         createNSResolverUnchecked, js_evaluate, evaluate, evaluate_,
-        evaluateUnchecked, XPathEvaluator, castToXPathEvaluator,
+        evaluateUnsafe, evaluateUnchecked, XPathEvaluator(..),
         gTypeXPathEvaluator)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -23,6 +30,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "new window[\"XPathEvaluator\"]()"
         js_newXPathEvaluator :: IO XPathEvaluator
@@ -59,6 +76,18 @@
             (maybeToNullable resolver)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/XPathEvaluator.createExpression Mozilla XPathEvaluator.createExpression documentation> 
+createExpressionUnsafe ::
+                       (MonadIO m, ToJSString expression, HasCallStack) =>
+                         XPathEvaluator ->
+                           expression -> Maybe XPathNSResolver -> m XPathExpression
+createExpressionUnsafe self expression resolver
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_createExpression (self) (toJSString expression)
+             (maybeToNullable resolver)))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/XPathEvaluator.createExpression Mozilla XPathEvaluator.createExpression documentation> 
 createExpressionUnchecked ::
                           (MonadIO m, ToJSString expression) =>
                             XPathEvaluator ->
@@ -94,6 +123,17 @@
             (maybeToNullable (fmap toNode nodeResolver))))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/XPathEvaluator.createNSResolver Mozilla XPathEvaluator.createNSResolver documentation> 
+createNSResolverUnsafe ::
+                       (MonadIO m, IsNode nodeResolver, HasCallStack) =>
+                         XPathEvaluator -> Maybe nodeResolver -> m XPathNSResolver
+createNSResolverUnsafe self nodeResolver
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_createNSResolver (self)
+             (maybeToNullable (fmap toNode nodeResolver))))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/XPathEvaluator.createNSResolver Mozilla XPathEvaluator.createNSResolver documentation> 
 createNSResolverUnchecked ::
                           (MonadIO m, IsNode nodeResolver) =>
                             XPathEvaluator -> Maybe nodeResolver -> m XPathNSResolver
@@ -143,6 +183,24 @@
             (maybeToNullable resolver)
             type'
             (maybeToNullable inResult)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/XPathEvaluator.evaluate Mozilla XPathEvaluator.evaluate documentation> 
+evaluateUnsafe ::
+               (MonadIO m, ToJSString expression, IsNode contextNode,
+                HasCallStack) =>
+                 XPathEvaluator ->
+                   expression ->
+                     Maybe contextNode ->
+                       Maybe XPathNSResolver -> Word -> Maybe XPathResult -> m XPathResult
+evaluateUnsafe self expression contextNode resolver type' inResult
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_evaluate (self) (toJSString expression)
+             (maybeToNullable (fmap toNode contextNode))
+             (maybeToNullable resolver)
+             type'
+             (maybeToNullable inResult)))
+         >>= maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/XPathEvaluator.evaluate Mozilla XPathEvaluator.evaluate documentation> 
 evaluateUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/XPathExpression.hs b/src/GHCJS/DOM/JSFFI/Generated/XPathExpression.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/XPathExpression.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/XPathExpression.hs
@@ -1,9 +1,15 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.XPathExpression
-       (js_evaluate, evaluate, evaluate_, evaluateUnchecked,
-        XPathExpression, castToXPathExpression, gTypeXPathExpression)
+       (js_evaluate, evaluate, evaluate_, evaluateUnsafe,
+        evaluateUnchecked, XPathExpression(..), gTypeXPathExpression)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -19,6 +25,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"evaluate\"]($2, $3, $4)"
         js_evaluate ::
@@ -50,6 +66,19 @@
          (js_evaluate (self) (maybeToNullable (fmap toNode contextNode))
             type'
             (maybeToNullable inResult)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/XPathExpression.evaluate Mozilla XPathExpression.evaluate documentation> 
+evaluateUnsafe ::
+               (MonadIO m, IsNode contextNode, HasCallStack) =>
+                 XPathExpression ->
+                   Maybe contextNode -> Word -> Maybe XPathResult -> m XPathResult
+evaluateUnsafe self contextNode type' inResult
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_evaluate (self) (maybeToNullable (fmap toNode contextNode))
+             type'
+             (maybeToNullable inResult)))
+         >>= maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/XPathExpression.evaluate Mozilla XPathExpression.evaluate documentation> 
 evaluateUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/XPathNSResolver.hs b/src/GHCJS/DOM/JSFFI/Generated/XPathNSResolver.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/XPathNSResolver.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/XPathNSResolver.hs
@@ -1,10 +1,16 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.XPathNSResolver
        (js_lookupNamespaceURI, lookupNamespaceURI, lookupNamespaceURI_,
-        lookupNamespaceURIUnchecked, XPathNSResolver,
-        castToXPathNSResolver, gTypeXPathNSResolver)
+        lookupNamespaceURIUnsafe, lookupNamespaceURIUnchecked,
+        XPathNSResolver(..), gTypeXPathNSResolver)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -20,6 +26,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"lookupNamespaceURI\"]($2)"
         js_lookupNamespaceURI ::
@@ -39,6 +55,17 @@
                     (MonadIO m, ToJSString prefix) => XPathNSResolver -> prefix -> m ()
 lookupNamespaceURI_ self prefix
   = liftIO (void (js_lookupNamespaceURI (self) (toJSString prefix)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/XPathNSResolver.lookupNamespaceURI Mozilla XPathNSResolver.lookupNamespaceURI documentation> 
+lookupNamespaceURIUnsafe ::
+                         (MonadIO m, ToJSString prefix, HasCallStack,
+                          FromJSString result) =>
+                           XPathNSResolver -> prefix -> m result
+lookupNamespaceURIUnsafe self prefix
+  = liftIO
+      ((fromMaybeJSString <$>
+          (js_lookupNamespaceURI (self) (toJSString prefix)))
+         >>= maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/XPathNSResolver.lookupNamespaceURI Mozilla XPathNSResolver.lookupNamespaceURI documentation> 
 lookupNamespaceURIUnchecked ::
diff --git a/src/GHCJS/DOM/JSFFI/Generated/XPathResult.hs b/src/GHCJS/DOM/JSFFI/Generated/XPathResult.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/XPathResult.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/XPathResult.hs
@@ -1,9 +1,14 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.XPathResult
-       (js_iterateNext, iterateNext, iterateNext_, iterateNextUnchecked,
-        js_snapshotItem, snapshotItem, snapshotItem_,
-        snapshotItemUnchecked, pattern ANY_TYPE, pattern NUMBER_TYPE,
-        pattern STRING_TYPE, pattern BOOLEAN_TYPE,
+       (js_iterateNext, iterateNext, iterateNext_, iterateNextUnsafe,
+        iterateNextUnchecked, js_snapshotItem, snapshotItem, snapshotItem_,
+        snapshotItemUnsafe, snapshotItemUnchecked, pattern ANY_TYPE,
+        pattern NUMBER_TYPE, pattern STRING_TYPE, pattern BOOLEAN_TYPE,
         pattern UNORDERED_NODE_ITERATOR_TYPE,
         pattern ORDERED_NODE_ITERATOR_TYPE,
         pattern UNORDERED_NODE_SNAPSHOT_TYPE,
@@ -12,11 +17,13 @@
         js_getResultType, getResultType, js_getNumberValue, getNumberValue,
         js_getStringValue, getStringValue, js_getBooleanValue,
         getBooleanValue, js_getSingleNodeValue, getSingleNodeValue,
-        getSingleNodeValueUnchecked, js_getInvalidIteratorState,
-        getInvalidIteratorState, js_getSnapshotLength, getSnapshotLength,
-        XPathResult, castToXPathResult, gTypeXPathResult)
+        getSingleNodeValueUnsafe, getSingleNodeValueUnchecked,
+        js_getInvalidIteratorState, getInvalidIteratorState,
+        js_getSnapshotLength, getSnapshotLength, XPathResult(..),
+        gTypeXPathResult)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -32,6 +39,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "$1[\"iterateNext\"]()"
         js_iterateNext :: XPathResult -> IO (Nullable Node)
@@ -46,6 +63,14 @@
 iterateNext_ self = liftIO (void (js_iterateNext (self)))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/XPathResult.iterateNext Mozilla XPathResult.iterateNext documentation> 
+iterateNextUnsafe ::
+                  (MonadIO m, HasCallStack) => XPathResult -> m Node
+iterateNextUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_iterateNext (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/XPathResult.iterateNext Mozilla XPathResult.iterateNext documentation> 
 iterateNextUnchecked :: (MonadIO m) => XPathResult -> m Node
 iterateNextUnchecked self
   = liftIO (fromJust . nullableToMaybe <$> (js_iterateNext (self)))
@@ -65,6 +90,14 @@
   = liftIO (void (js_snapshotItem (self) index))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/XPathResult.snapshotItem Mozilla XPathResult.snapshotItem documentation> 
+snapshotItemUnsafe ::
+                   (MonadIO m, HasCallStack) => XPathResult -> Word -> m Node
+snapshotItemUnsafe self index
+  = liftIO
+      ((nullableToMaybe <$> (js_snapshotItem (self) index)) >>=
+         maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/XPathResult.snapshotItem Mozilla XPathResult.snapshotItem documentation> 
 snapshotItemUnchecked ::
                       (MonadIO m) => XPathResult -> Word -> m Node
 snapshotItemUnchecked self index
@@ -118,6 +151,14 @@
 getSingleNodeValue :: (MonadIO m) => XPathResult -> m (Maybe Node)
 getSingleNodeValue self
   = liftIO (nullableToMaybe <$> (js_getSingleNodeValue (self)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/XPathResult.singleNodeValue Mozilla XPathResult.singleNodeValue documentation> 
+getSingleNodeValueUnsafe ::
+                         (MonadIO m, HasCallStack) => XPathResult -> m Node
+getSingleNodeValueUnsafe self
+  = liftIO
+      ((nullableToMaybe <$> (js_getSingleNodeValue (self))) >>=
+         maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/XPathResult.singleNodeValue Mozilla XPathResult.singleNodeValue documentation> 
 getSingleNodeValueUnchecked :: (MonadIO m) => XPathResult -> m Node
diff --git a/src/GHCJS/DOM/JSFFI/Generated/XSLTProcessor.hs b/src/GHCJS/DOM/JSFFI/Generated/XSLTProcessor.hs
--- a/src/GHCJS/DOM/JSFFI/Generated/XSLTProcessor.hs
+++ b/src/GHCJS/DOM/JSFFI/Generated/XSLTProcessor.hs
@@ -1,16 +1,24 @@
-{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
 module GHCJS.DOM.JSFFI.Generated.XSLTProcessor
        (js_newXSLTProcessor, newXSLTProcessor, js_importStylesheet,
         importStylesheet, js_transformToFragment, transformToFragment,
-        transformToFragment_, transformToFragmentUnchecked,
-        js_transformToDocument, transformToDocument, transformToDocument_,
-        transformToDocumentUnchecked, js_setParameter, setParameter,
-        js_getParameter, getParameter, getParameter_,
-        getParameterUnchecked, js_removeParameter, removeParameter,
-        js_clearParameters, clearParameters, js_reset, reset,
-        XSLTProcessor, castToXSLTProcessor, gTypeXSLTProcessor)
+        transformToFragment_, transformToFragmentUnsafe,
+        transformToFragmentUnchecked, js_transformToDocument,
+        transformToDocument, transformToDocument_,
+        transformToDocumentUnsafe, transformToDocumentUnchecked,
+        js_setParameter, setParameter, js_getParameter, getParameter,
+        getParameter_, getParameterUnsafe, getParameterUnchecked,
+        js_removeParameter, removeParameter, js_clearParameters,
+        clearParameters, js_reset, reset, XSLTProcessor(..),
+        gTypeXSLTProcessor)
        where
 import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
+import qualified Prelude (error)
 import Data.Typeable (Typeable)
 import GHCJS.Types (JSVal(..), JSString)
 import GHCJS.Foreign (jsNull)
@@ -26,6 +34,16 @@
 import Control.Applicative ((<$>))
 import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
 import GHCJS.DOM.JSFFI.Generated.Enums
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
  
 foreign import javascript unsafe "new window[\"XSLTProcessor\"]()"
         js_newXSLTProcessor :: IO XSLTProcessor
@@ -76,6 +94,18 @@
             (maybeToNullable (fmap toDocument docVal))))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/XSLTProcessor.transformToFragment Mozilla XSLTProcessor.transformToFragment documentation> 
+transformToFragmentUnsafe ::
+                          (MonadIO m, IsNode source, IsDocument docVal, HasCallStack) =>
+                            XSLTProcessor -> Maybe source -> Maybe docVal -> m DocumentFragment
+transformToFragmentUnsafe self source docVal
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_transformToFragment (self)
+             (maybeToNullable (fmap toNode source))
+             (maybeToNullable (fmap toDocument docVal))))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/XSLTProcessor.transformToFragment Mozilla XSLTProcessor.transformToFragment documentation> 
 transformToFragmentUnchecked ::
                              (MonadIO m, IsNode source, IsDocument docVal) =>
                                XSLTProcessor -> Maybe source -> Maybe docVal -> m DocumentFragment
@@ -110,6 +140,17 @@
             (maybeToNullable (fmap toNode source))))
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/XSLTProcessor.transformToDocument Mozilla XSLTProcessor.transformToDocument documentation> 
+transformToDocumentUnsafe ::
+                          (MonadIO m, IsNode source, HasCallStack) =>
+                            XSLTProcessor -> Maybe source -> m Document
+transformToDocumentUnsafe self source
+  = liftIO
+      ((nullableToMaybe <$>
+          (js_transformToDocument (self)
+             (maybeToNullable (fmap toNode source))))
+         >>= maybe (Prelude.error "Nothing to return") return)
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/XSLTProcessor.transformToDocument Mozilla XSLTProcessor.transformToDocument documentation> 
 transformToDocumentUnchecked ::
                              (MonadIO m, IsNode source) =>
                                XSLTProcessor -> Maybe source -> m Document
@@ -158,6 +199,18 @@
       (void
          (js_getParameter (self) (toJSString namespaceURI)
             (toJSString localName)))
+
+-- | <https://developer.mozilla.org/en-US/docs/Web/API/XSLTProcessor.getParameter Mozilla XSLTProcessor.getParameter documentation> 
+getParameterUnsafe ::
+                   (MonadIO m, ToJSString namespaceURI, ToJSString localName,
+                    HasCallStack, FromJSString result) =>
+                     XSLTProcessor -> namespaceURI -> localName -> m result
+getParameterUnsafe self namespaceURI localName
+  = liftIO
+      ((fromMaybeJSString <$>
+          (js_getParameter (self) (toJSString namespaceURI)
+             (toJSString localName)))
+         >>= maybe (Prelude.error "Nothing to return") return)
 
 -- | <https://developer.mozilla.org/en-US/docs/Web/API/XSLTProcessor.getParameter Mozilla XSLTProcessor.getParameter documentation> 
 getParameterUnchecked ::
diff --git a/src/GHCJS/DOM/Types.hs b/src/GHCJS/DOM/Types.hs
--- a/src/GHCJS/DOM/Types.hs
+++ b/src/GHCJS/DOM/Types.hs
@@ -1,24200 +1,20778 @@
-{-# LANGUAGE JavaScriptFFI, ForeignFunctionInterface, ConstraintKinds, FlexibleInstances #-}
-module GHCJS.DOM.Types (
-  -- * JavaScript Context and Monad
-    JSContextRef(..), JSM, askJSM, runJSM, MonadJSM(..), liftJSM
-
-  -- * DOM Context and Monad
-  , DOMContext(..), DOM, askDOM, runDOM, MonadDOM(..), liftDOM
-
-  -- * JavaScript Value
-  , JSVal(..), ToJSVal(..), FromJSVal(..), PToJSVal(..), PFromJSVal(..)
-
-  -- * JavaScript String
-  , JSString(..), ToJSString(..), FromJSString(..)
-  , toJSString, fromJSString, toMaybeJSString, fromMaybeJSString
-
-  -- * Nullable
-  , Nullable(..), nullableToMaybe, maybeToNullable
-
-  -- * DOM String
-  , DOMString(..), ToDOMString(..), FromDOMString(..), IsDOMString
-
-  -- * Object
-  , maybeJSNullOrUndefined, GType(..)
-  , GObject(..), IsGObject, toGObject, castToGObject, gTypeGObject, unsafeCastGObject, isA, objectToString
-  , js_eq, strictEqual
-
-  -- * Callbacks
-  , AudioBufferCallback(..)
-  , DatabaseCallback(..)
-  , MediaQueryListListener(..)
-  , MediaStreamTrackSourcesCallback(..)
-  , NavigatorUserMediaErrorCallback(..)
-  , NavigatorUserMediaSuccessCallback(..)
-  , NotificationPermissionCallback(..)
-  , PositionCallback(..)
-  , PositionErrorCallback(..)
-  , RequestAnimationFrameCallback(..)
-  , RTCPeerConnectionErrorCallback(..)
-  , RTCSessionDescriptionCallback(..)
-  , RTCStatsCallback(..)
-  , SQLStatementCallback(..)
-  , SQLStatementErrorCallback(..)
-  , SQLTransactionCallback(..)
-  , SQLTransactionErrorCallback(..)
-  , StorageErrorCallback(..)
-  , StorageQuotaCallback(..)
-  , StorageUsageCallback(..)
-  , StringCallback(..)
-  , VoidCallback(..)
-
-  -- * Dictionaries
-  , Dictionary(Dictionary), unDictionary, IsDictionary, toDictionary
-  , BlobPropertyBag(BlobPropertyBag), unBlobPropertyBag, IsBlobPropertyBag, toBlobPropertyBag
-
-  -- * Mutation Callback
-  , MutationCallback(MutationCallback), unMutationCallback, IsMutationCallback, toMutationCallback
-
-  -- * Promise
-  , Promise(Promise), unPromise, IsPromise, toPromise, castToPromise, gTypePromise
-
-  -- * Date
-  , Date(Date), unDate, IsDate, toDate, castToDate, gTypeDate
-
-  -- * Arrays
-  , Array(Array), unArray, IsArray, toArray, castToArray, gTypeArray
-  , ObjectArray(ObjectArray), unObjectArray, IsObjectArray, toObjectArray
-  , ArrayBuffer(ArrayBuffer), unArrayBuffer, IsArrayBuffer, toArrayBuffer, castToArrayBuffer, gTypeArrayBuffer
-  , ArrayBufferView(ArrayBufferView), unArrayBufferView, IsArrayBufferView, toArrayBufferView
-  , Float32Array(Float32Array), unFloat32Array, IsFloat32Array, toFloat32Array, castToFloat32Array, gTypeFloat32Array
-  , Float64Array(Float64Array), unFloat64Array, IsFloat64Array, toFloat64Array, castToFloat64Array, gTypeFloat64Array
-  , Uint8Array(Uint8Array), unUint8Array, IsUint8Array, toUint8Array, castToUint8Array, gTypeUint8Array
-  , Uint8ClampedArray(Uint8ClampedArray), unUint8ClampedArray, IsUint8ClampedArray, toUint8ClampedArray, castToUint8ClampedArray, gTypeUint8ClampedArray
-  , Uint16Array(Uint16Array), unUint16Array, IsUint16Array, toUint16Array, castToUint16Array, gTypeUint16Array
-  , Uint32Array(Uint32Array), unUint32Array, IsUint32Array, toUint32Array, castToUint32Array, gTypeUint32Array
-  , Int8Array(Int8Array), unInt8Array, IsInt8Array, toInt8Array, castToInt8Array, gTypeInt8Array
-  , Int16Array(Int16Array), unInt16Array, IsInt16Array, toInt16Array, castToInt16Array, gTypeInt16Array
-  , Int32Array(Int32Array), unInt32Array, IsInt32Array, toInt32Array, castToInt32Array, gTypeInt32Array
-
-  -- * Geolocation
-  , SerializedScriptValue(SerializedScriptValue), unSerializedScriptValue, IsSerializedScriptValue, toSerializedScriptValue
-  , PositionOptions(PositionOptions), unPositionOptions, IsPositionOptions, toPositionOptions
-  , Acceleration(Acceleration), unAcceleration, IsAcceleration, toAcceleration
-  , RotationRate(RotationRate), unRotationRate, IsRotationRate, toRotationRate
-
-  -- * Crypto
-  , Algorithm(Algorithm), unAlgorithm, IsAlgorithm, toAlgorithm
-  , CryptoOperationData(CryptoOperationData), unCryptoOperationData, IsCryptoOperationData, toCryptoOperationData
-
-  -- * CanvasStyle (fill & stroke style)
-  , CanvasStyle(CanvasStyle), unCanvasStyle, IsCanvasStyle, toCanvasStyle
-
-  , DOMException(DOMException), unDOMException, IsDOMException, toDOMException
-
-  -- * WebGL typedefs
-  , GLenum(..), GLboolean(..), GLbitfield(..), GLbyte(..), GLshort(..), GLint(..), GLsizei(..)
-  , GLintptr(..), GLsizeiptr(..), GLubyte(..), GLushort(..), GLuint(..), GLfloat(..), GLclampf(..)
-  , GLint64, GLuint64
-
-  -- * Interface types from IDL files
-
--- AUTO GENERATION STARTS HERE
-  , ANGLEInstancedArrays(ANGLEInstancedArrays), unANGLEInstancedArrays, castToANGLEInstancedArrays, gTypeANGLEInstancedArrays
-  , AbstractView(AbstractView), unAbstractView, castToAbstractView, gTypeAbstractView
-  , AbstractWorker(AbstractWorker), unAbstractWorker, castToAbstractWorker, gTypeAbstractWorker
-  , AllAudioCapabilities(AllAudioCapabilities), unAllAudioCapabilities, castToAllAudioCapabilities, gTypeAllAudioCapabilities
-  , AllVideoCapabilities(AllVideoCapabilities), unAllVideoCapabilities, castToAllVideoCapabilities, gTypeAllVideoCapabilities
-  , AnalyserNode(AnalyserNode), unAnalyserNode, castToAnalyserNode, gTypeAnalyserNode
-  , AnimationEvent(AnimationEvent), unAnimationEvent, castToAnimationEvent, gTypeAnimationEvent
-  , ApplicationCache(ApplicationCache), unApplicationCache, castToApplicationCache, gTypeApplicationCache
-  , Attr(Attr), unAttr, castToAttr, gTypeAttr
-  , AudioBuffer(AudioBuffer), unAudioBuffer, castToAudioBuffer, gTypeAudioBuffer
-  , AudioBufferSourceNode(AudioBufferSourceNode), unAudioBufferSourceNode, castToAudioBufferSourceNode, gTypeAudioBufferSourceNode
-  , AudioContext(AudioContext), unAudioContext, IsAudioContext, toAudioContext, castToAudioContext, gTypeAudioContext
-  , AudioDestinationNode(AudioDestinationNode), unAudioDestinationNode, castToAudioDestinationNode, gTypeAudioDestinationNode
-  , AudioListener(AudioListener), unAudioListener, castToAudioListener, gTypeAudioListener
-  , AudioNode(AudioNode), unAudioNode, IsAudioNode, toAudioNode, castToAudioNode, gTypeAudioNode
-  , AudioParam(AudioParam), unAudioParam, castToAudioParam, gTypeAudioParam
-  , AudioProcessingEvent(AudioProcessingEvent), unAudioProcessingEvent, castToAudioProcessingEvent, gTypeAudioProcessingEvent
-  , AudioStreamTrack(AudioStreamTrack), unAudioStreamTrack, castToAudioStreamTrack, gTypeAudioStreamTrack
-  , AudioTrack(AudioTrack), unAudioTrack, castToAudioTrack, gTypeAudioTrack
-  , AudioTrackList(AudioTrackList), unAudioTrackList, castToAudioTrackList, gTypeAudioTrackList
-  , AutocompleteErrorEvent(AutocompleteErrorEvent), unAutocompleteErrorEvent, castToAutocompleteErrorEvent, gTypeAutocompleteErrorEvent
-  , BarProp(BarProp), unBarProp, castToBarProp, gTypeBarProp
-  , BatteryManager(BatteryManager), unBatteryManager, castToBatteryManager, gTypeBatteryManager
-  , BeforeLoadEvent(BeforeLoadEvent), unBeforeLoadEvent, castToBeforeLoadEvent, gTypeBeforeLoadEvent
-  , BeforeUnloadEvent(BeforeUnloadEvent), unBeforeUnloadEvent, castToBeforeUnloadEvent, gTypeBeforeUnloadEvent
-  , BiquadFilterNode(BiquadFilterNode), unBiquadFilterNode, castToBiquadFilterNode, gTypeBiquadFilterNode
-  , Blob(Blob), unBlob, IsBlob, toBlob, castToBlob, gTypeBlob
-  , CDATASection(CDATASection), unCDATASection, castToCDATASection, gTypeCDATASection
-  , CSS(CSS), unCSS, castToCSS, gTypeCSS
-  , CSSCharsetRule(CSSCharsetRule), unCSSCharsetRule, castToCSSCharsetRule, gTypeCSSCharsetRule
-  , CSSFontFaceLoadEvent(CSSFontFaceLoadEvent), unCSSFontFaceLoadEvent, castToCSSFontFaceLoadEvent, gTypeCSSFontFaceLoadEvent
-  , CSSFontFaceRule(CSSFontFaceRule), unCSSFontFaceRule, castToCSSFontFaceRule, gTypeCSSFontFaceRule
-  , CSSImportRule(CSSImportRule), unCSSImportRule, castToCSSImportRule, gTypeCSSImportRule
-  , CSSKeyframeRule(CSSKeyframeRule), unCSSKeyframeRule, castToCSSKeyframeRule, gTypeCSSKeyframeRule
-  , CSSKeyframesRule(CSSKeyframesRule), unCSSKeyframesRule, castToCSSKeyframesRule, gTypeCSSKeyframesRule
-  , CSSMediaRule(CSSMediaRule), unCSSMediaRule, castToCSSMediaRule, gTypeCSSMediaRule
-  , CSSPageRule(CSSPageRule), unCSSPageRule, castToCSSPageRule, gTypeCSSPageRule
-  , CSSPrimitiveValue(CSSPrimitiveValue), unCSSPrimitiveValue, castToCSSPrimitiveValue, gTypeCSSPrimitiveValue
-  , CSSRule(CSSRule), unCSSRule, IsCSSRule, toCSSRule, castToCSSRule, gTypeCSSRule
-  , CSSRuleList(CSSRuleList), unCSSRuleList, castToCSSRuleList, gTypeCSSRuleList
-  , CSSStyleDeclaration(CSSStyleDeclaration), unCSSStyleDeclaration, castToCSSStyleDeclaration, gTypeCSSStyleDeclaration
-  , CSSStyleRule(CSSStyleRule), unCSSStyleRule, castToCSSStyleRule, gTypeCSSStyleRule
-  , CSSStyleSheet(CSSStyleSheet), unCSSStyleSheet, castToCSSStyleSheet, gTypeCSSStyleSheet
-  , CSSSupportsRule(CSSSupportsRule), unCSSSupportsRule, castToCSSSupportsRule, gTypeCSSSupportsRule
-  , CSSUnknownRule(CSSUnknownRule), unCSSUnknownRule, castToCSSUnknownRule, gTypeCSSUnknownRule
-  , CSSValue(CSSValue), unCSSValue, IsCSSValue, toCSSValue, castToCSSValue, gTypeCSSValue
-  , CSSValueList(CSSValueList), unCSSValueList, IsCSSValueList, toCSSValueList, castToCSSValueList, gTypeCSSValueList
-  , CanvasGradient(CanvasGradient), unCanvasGradient, castToCanvasGradient, gTypeCanvasGradient
-  , CanvasPattern(CanvasPattern), unCanvasPattern, castToCanvasPattern, gTypeCanvasPattern
-  , CanvasProxy(CanvasProxy), unCanvasProxy, castToCanvasProxy, gTypeCanvasProxy
-  , CanvasRenderingContext(CanvasRenderingContext), unCanvasRenderingContext, IsCanvasRenderingContext, toCanvasRenderingContext, castToCanvasRenderingContext, gTypeCanvasRenderingContext
-  , CanvasRenderingContext2D(CanvasRenderingContext2D), unCanvasRenderingContext2D, castToCanvasRenderingContext2D, gTypeCanvasRenderingContext2D
-  , CapabilityRange(CapabilityRange), unCapabilityRange, castToCapabilityRange, gTypeCapabilityRange
-  , ChannelMergerNode(ChannelMergerNode), unChannelMergerNode, castToChannelMergerNode, gTypeChannelMergerNode
-  , ChannelSplitterNode(ChannelSplitterNode), unChannelSplitterNode, castToChannelSplitterNode, gTypeChannelSplitterNode
-  , CharacterData(CharacterData), unCharacterData, IsCharacterData, toCharacterData, castToCharacterData, gTypeCharacterData
-  , ChildNode(ChildNode), unChildNode, castToChildNode, gTypeChildNode
-  , ClientRect(ClientRect), unClientRect, castToClientRect, gTypeClientRect
-  , ClientRectList(ClientRectList), unClientRectList, castToClientRectList, gTypeClientRectList
-  , CloseEvent(CloseEvent), unCloseEvent, castToCloseEvent, gTypeCloseEvent
-  , CommandLineAPIHost(CommandLineAPIHost), unCommandLineAPIHost, castToCommandLineAPIHost, gTypeCommandLineAPIHost
-  , Comment(Comment), unComment, castToComment, gTypeComment
-  , CompositionEvent(CompositionEvent), unCompositionEvent, castToCompositionEvent, gTypeCompositionEvent
-  , ConvolverNode(ConvolverNode), unConvolverNode, castToConvolverNode, gTypeConvolverNode
-  , Coordinates(Coordinates), unCoordinates, castToCoordinates, gTypeCoordinates
-  , Counter(Counter), unCounter, castToCounter, gTypeCounter
-  , Crypto(Crypto), unCrypto, castToCrypto, gTypeCrypto
-  , CryptoKey(CryptoKey), unCryptoKey, castToCryptoKey, gTypeCryptoKey
-  , CryptoKeyPair(CryptoKeyPair), unCryptoKeyPair, castToCryptoKeyPair, gTypeCryptoKeyPair
-  , CustomEvent(CustomEvent), unCustomEvent, castToCustomEvent, gTypeCustomEvent
-  , DOMError(DOMError), unDOMError, IsDOMError, toDOMError, castToDOMError, gTypeDOMError
-  , DOMImplementation(DOMImplementation), unDOMImplementation, castToDOMImplementation, gTypeDOMImplementation
-  , DOMNamedFlowCollection(DOMNamedFlowCollection), unDOMNamedFlowCollection, castToDOMNamedFlowCollection, gTypeDOMNamedFlowCollection
-  , DOMParser(DOMParser), unDOMParser, castToDOMParser, gTypeDOMParser
-  , DOMSettableTokenList(DOMSettableTokenList), unDOMSettableTokenList, castToDOMSettableTokenList, gTypeDOMSettableTokenList
-  , DOMStringList(DOMStringList), unDOMStringList, castToDOMStringList, gTypeDOMStringList
-  , DOMStringMap(DOMStringMap), unDOMStringMap, castToDOMStringMap, gTypeDOMStringMap
-  , DOMTokenList(DOMTokenList), unDOMTokenList, IsDOMTokenList, toDOMTokenList, castToDOMTokenList, gTypeDOMTokenList
-  , DataCue(DataCue), unDataCue, castToDataCue, gTypeDataCue
-  , DataTransfer(DataTransfer), unDataTransfer, castToDataTransfer, gTypeDataTransfer
-  , DataTransferItem(DataTransferItem), unDataTransferItem, castToDataTransferItem, gTypeDataTransferItem
-  , DataTransferItemList(DataTransferItemList), unDataTransferItemList, castToDataTransferItemList, gTypeDataTransferItemList
-  , Database(Database), unDatabase, castToDatabase, gTypeDatabase
-  , DedicatedWorkerGlobalScope(DedicatedWorkerGlobalScope), unDedicatedWorkerGlobalScope, castToDedicatedWorkerGlobalScope, gTypeDedicatedWorkerGlobalScope
-  , DelayNode(DelayNode), unDelayNode, castToDelayNode, gTypeDelayNode
-  , DeviceMotionEvent(DeviceMotionEvent), unDeviceMotionEvent, castToDeviceMotionEvent, gTypeDeviceMotionEvent
-  , DeviceOrientationEvent(DeviceOrientationEvent), unDeviceOrientationEvent, castToDeviceOrientationEvent, gTypeDeviceOrientationEvent
-  , DeviceProximityEvent(DeviceProximityEvent), unDeviceProximityEvent, castToDeviceProximityEvent, gTypeDeviceProximityEvent
-  , Document(Document), unDocument, IsDocument, toDocument, castToDocument, gTypeDocument
-  , DocumentFragment(DocumentFragment), unDocumentFragment, castToDocumentFragment, gTypeDocumentFragment
-  , DocumentType(DocumentType), unDocumentType, castToDocumentType, gTypeDocumentType
-  , DynamicsCompressorNode(DynamicsCompressorNode), unDynamicsCompressorNode, castToDynamicsCompressorNode, gTypeDynamicsCompressorNode
-  , EXTBlendMinMax(EXTBlendMinMax), unEXTBlendMinMax, castToEXTBlendMinMax, gTypeEXTBlendMinMax
-  , EXTFragDepth(EXTFragDepth), unEXTFragDepth, castToEXTFragDepth, gTypeEXTFragDepth
-  , EXTShaderTextureLOD(EXTShaderTextureLOD), unEXTShaderTextureLOD, castToEXTShaderTextureLOD, gTypeEXTShaderTextureLOD
-  , EXTTextureFilterAnisotropic(EXTTextureFilterAnisotropic), unEXTTextureFilterAnisotropic, castToEXTTextureFilterAnisotropic, gTypeEXTTextureFilterAnisotropic
-  , EXTsRGB(EXTsRGB), unEXTsRGB, castToEXTsRGB, gTypeEXTsRGB
-  , Element(Element), unElement, IsElement, toElement, castToElement, gTypeElement
-  , Entity(Entity), unEntity, castToEntity, gTypeEntity
-  , EntityReference(EntityReference), unEntityReference, castToEntityReference, gTypeEntityReference
-  , ErrorEvent(ErrorEvent), unErrorEvent, castToErrorEvent, gTypeErrorEvent
-  , Event(Event), unEvent, IsEvent, toEvent, castToEvent, gTypeEvent
-  , EventListener(EventListener), unEventListener, castToEventListener, gTypeEventListener
-  , EventSource(EventSource), unEventSource, castToEventSource, gTypeEventSource
-  , EventTarget(EventTarget), unEventTarget, IsEventTarget, toEventTarget, castToEventTarget, gTypeEventTarget
-  , File(File), unFile, castToFile, gTypeFile
-  , FileError(FileError), unFileError, castToFileError, gTypeFileError
-  , FileList(FileList), unFileList, castToFileList, gTypeFileList
-  , FileReader(FileReader), unFileReader, castToFileReader, gTypeFileReader
-  , FileReaderSync(FileReaderSync), unFileReaderSync, castToFileReaderSync, gTypeFileReaderSync
-  , FocusEvent(FocusEvent), unFocusEvent, castToFocusEvent, gTypeFocusEvent
-  , FontLoader(FontLoader), unFontLoader, castToFontLoader, gTypeFontLoader
-  , FormData(FormData), unFormData, castToFormData, gTypeFormData
-  , GainNode(GainNode), unGainNode, castToGainNode, gTypeGainNode
-  , Gamepad(Gamepad), unGamepad, castToGamepad, gTypeGamepad
-  , GamepadButton(GamepadButton), unGamepadButton, castToGamepadButton, gTypeGamepadButton
-  , GamepadEvent(GamepadEvent), unGamepadEvent, castToGamepadEvent, gTypeGamepadEvent
-  , Geolocation(Geolocation), unGeolocation, castToGeolocation, gTypeGeolocation
-  , Geoposition(Geoposition), unGeoposition, castToGeoposition, gTypeGeoposition
-  , HTMLAllCollection(HTMLAllCollection), unHTMLAllCollection, castToHTMLAllCollection, gTypeHTMLAllCollection
-  , HTMLAnchorElement(HTMLAnchorElement), unHTMLAnchorElement, castToHTMLAnchorElement, gTypeHTMLAnchorElement
-  , HTMLAppletElement(HTMLAppletElement), unHTMLAppletElement, castToHTMLAppletElement, gTypeHTMLAppletElement
-  , HTMLAreaElement(HTMLAreaElement), unHTMLAreaElement, castToHTMLAreaElement, gTypeHTMLAreaElement
-  , HTMLAudioElement(HTMLAudioElement), unHTMLAudioElement, castToHTMLAudioElement, gTypeHTMLAudioElement
-  , HTMLBRElement(HTMLBRElement), unHTMLBRElement, castToHTMLBRElement, gTypeHTMLBRElement
-  , HTMLBaseElement(HTMLBaseElement), unHTMLBaseElement, castToHTMLBaseElement, gTypeHTMLBaseElement
-  , HTMLBaseFontElement(HTMLBaseFontElement), unHTMLBaseFontElement, castToHTMLBaseFontElement, gTypeHTMLBaseFontElement
-  , HTMLBodyElement(HTMLBodyElement), unHTMLBodyElement, castToHTMLBodyElement, gTypeHTMLBodyElement
-  , HTMLButtonElement(HTMLButtonElement), unHTMLButtonElement, castToHTMLButtonElement, gTypeHTMLButtonElement
-  , HTMLCanvasElement(HTMLCanvasElement), unHTMLCanvasElement, castToHTMLCanvasElement, gTypeHTMLCanvasElement
-  , HTMLCollection(HTMLCollection), unHTMLCollection, IsHTMLCollection, toHTMLCollection, castToHTMLCollection, gTypeHTMLCollection
-  , HTMLDListElement(HTMLDListElement), unHTMLDListElement, castToHTMLDListElement, gTypeHTMLDListElement
-  , HTMLDataListElement(HTMLDataListElement), unHTMLDataListElement, castToHTMLDataListElement, gTypeHTMLDataListElement
-  , HTMLDetailsElement(HTMLDetailsElement), unHTMLDetailsElement, castToHTMLDetailsElement, gTypeHTMLDetailsElement
-  , HTMLDirectoryElement(HTMLDirectoryElement), unHTMLDirectoryElement, castToHTMLDirectoryElement, gTypeHTMLDirectoryElement
-  , HTMLDivElement(HTMLDivElement), unHTMLDivElement, castToHTMLDivElement, gTypeHTMLDivElement
-  , HTMLDocument(HTMLDocument), unHTMLDocument, castToHTMLDocument, gTypeHTMLDocument
-  , HTMLElement(HTMLElement), unHTMLElement, IsHTMLElement, toHTMLElement, castToHTMLElement, gTypeHTMLElement
-  , HTMLEmbedElement(HTMLEmbedElement), unHTMLEmbedElement, castToHTMLEmbedElement, gTypeHTMLEmbedElement
-  , HTMLFieldSetElement(HTMLFieldSetElement), unHTMLFieldSetElement, castToHTMLFieldSetElement, gTypeHTMLFieldSetElement
-  , HTMLFontElement(HTMLFontElement), unHTMLFontElement, castToHTMLFontElement, gTypeHTMLFontElement
-  , HTMLFormControlsCollection(HTMLFormControlsCollection), unHTMLFormControlsCollection, castToHTMLFormControlsCollection, gTypeHTMLFormControlsCollection
-  , HTMLFormElement(HTMLFormElement), unHTMLFormElement, castToHTMLFormElement, gTypeHTMLFormElement
-  , HTMLFrameElement(HTMLFrameElement), unHTMLFrameElement, castToHTMLFrameElement, gTypeHTMLFrameElement
-  , HTMLFrameSetElement(HTMLFrameSetElement), unHTMLFrameSetElement, castToHTMLFrameSetElement, gTypeHTMLFrameSetElement
-  , HTMLHRElement(HTMLHRElement), unHTMLHRElement, castToHTMLHRElement, gTypeHTMLHRElement
-  , HTMLHeadElement(HTMLHeadElement), unHTMLHeadElement, castToHTMLHeadElement, gTypeHTMLHeadElement
-  , HTMLHeadingElement(HTMLHeadingElement), unHTMLHeadingElement, castToHTMLHeadingElement, gTypeHTMLHeadingElement
-  , HTMLHtmlElement(HTMLHtmlElement), unHTMLHtmlElement, castToHTMLHtmlElement, gTypeHTMLHtmlElement
-  , HTMLIFrameElement(HTMLIFrameElement), unHTMLIFrameElement, castToHTMLIFrameElement, gTypeHTMLIFrameElement
-  , HTMLImageElement(HTMLImageElement), unHTMLImageElement, castToHTMLImageElement, gTypeHTMLImageElement
-  , HTMLInputElement(HTMLInputElement), unHTMLInputElement, castToHTMLInputElement, gTypeHTMLInputElement
-  , HTMLKeygenElement(HTMLKeygenElement), unHTMLKeygenElement, castToHTMLKeygenElement, gTypeHTMLKeygenElement
-  , HTMLLIElement(HTMLLIElement), unHTMLLIElement, castToHTMLLIElement, gTypeHTMLLIElement
-  , HTMLLabelElement(HTMLLabelElement), unHTMLLabelElement, castToHTMLLabelElement, gTypeHTMLLabelElement
-  , HTMLLegendElement(HTMLLegendElement), unHTMLLegendElement, castToHTMLLegendElement, gTypeHTMLLegendElement
-  , HTMLLinkElement(HTMLLinkElement), unHTMLLinkElement, castToHTMLLinkElement, gTypeHTMLLinkElement
-  , HTMLMapElement(HTMLMapElement), unHTMLMapElement, castToHTMLMapElement, gTypeHTMLMapElement
-  , HTMLMarqueeElement(HTMLMarqueeElement), unHTMLMarqueeElement, castToHTMLMarqueeElement, gTypeHTMLMarqueeElement
-  , HTMLMediaElement(HTMLMediaElement), unHTMLMediaElement, IsHTMLMediaElement, toHTMLMediaElement, castToHTMLMediaElement, gTypeHTMLMediaElement
-  , HTMLMenuElement(HTMLMenuElement), unHTMLMenuElement, castToHTMLMenuElement, gTypeHTMLMenuElement
-  , HTMLMetaElement(HTMLMetaElement), unHTMLMetaElement, castToHTMLMetaElement, gTypeHTMLMetaElement
-  , HTMLMeterElement(HTMLMeterElement), unHTMLMeterElement, castToHTMLMeterElement, gTypeHTMLMeterElement
-  , HTMLModElement(HTMLModElement), unHTMLModElement, castToHTMLModElement, gTypeHTMLModElement
-  , HTMLOListElement(HTMLOListElement), unHTMLOListElement, castToHTMLOListElement, gTypeHTMLOListElement
-  , HTMLObjectElement(HTMLObjectElement), unHTMLObjectElement, castToHTMLObjectElement, gTypeHTMLObjectElement
-  , HTMLOptGroupElement(HTMLOptGroupElement), unHTMLOptGroupElement, castToHTMLOptGroupElement, gTypeHTMLOptGroupElement
-  , HTMLOptionElement(HTMLOptionElement), unHTMLOptionElement, castToHTMLOptionElement, gTypeHTMLOptionElement
-  , HTMLOptionsCollection(HTMLOptionsCollection), unHTMLOptionsCollection, castToHTMLOptionsCollection, gTypeHTMLOptionsCollection
-  , HTMLOutputElement(HTMLOutputElement), unHTMLOutputElement, castToHTMLOutputElement, gTypeHTMLOutputElement
-  , HTMLParagraphElement(HTMLParagraphElement), unHTMLParagraphElement, castToHTMLParagraphElement, gTypeHTMLParagraphElement
-  , HTMLParamElement(HTMLParamElement), unHTMLParamElement, castToHTMLParamElement, gTypeHTMLParamElement
-  , HTMLPreElement(HTMLPreElement), unHTMLPreElement, castToHTMLPreElement, gTypeHTMLPreElement
-  , HTMLProgressElement(HTMLProgressElement), unHTMLProgressElement, castToHTMLProgressElement, gTypeHTMLProgressElement
-  , HTMLQuoteElement(HTMLQuoteElement), unHTMLQuoteElement, castToHTMLQuoteElement, gTypeHTMLQuoteElement
-  , HTMLScriptElement(HTMLScriptElement), unHTMLScriptElement, castToHTMLScriptElement, gTypeHTMLScriptElement
-  , HTMLSelectElement(HTMLSelectElement), unHTMLSelectElement, castToHTMLSelectElement, gTypeHTMLSelectElement
-  , HTMLSourceElement(HTMLSourceElement), unHTMLSourceElement, castToHTMLSourceElement, gTypeHTMLSourceElement
-  , HTMLSpanElement(HTMLSpanElement), unHTMLSpanElement, castToHTMLSpanElement, gTypeHTMLSpanElement
-  , HTMLStyleElement(HTMLStyleElement), unHTMLStyleElement, castToHTMLStyleElement, gTypeHTMLStyleElement
-  , HTMLTableCaptionElement(HTMLTableCaptionElement), unHTMLTableCaptionElement, castToHTMLTableCaptionElement, gTypeHTMLTableCaptionElement
-  , HTMLTableCellElement(HTMLTableCellElement), unHTMLTableCellElement, castToHTMLTableCellElement, gTypeHTMLTableCellElement
-  , HTMLTableColElement(HTMLTableColElement), unHTMLTableColElement, castToHTMLTableColElement, gTypeHTMLTableColElement
-  , HTMLTableElement(HTMLTableElement), unHTMLTableElement, castToHTMLTableElement, gTypeHTMLTableElement
-  , HTMLTableRowElement(HTMLTableRowElement), unHTMLTableRowElement, castToHTMLTableRowElement, gTypeHTMLTableRowElement
-  , HTMLTableSectionElement(HTMLTableSectionElement), unHTMLTableSectionElement, castToHTMLTableSectionElement, gTypeHTMLTableSectionElement
-  , HTMLTemplateElement(HTMLTemplateElement), unHTMLTemplateElement, castToHTMLTemplateElement, gTypeHTMLTemplateElement
-  , HTMLTextAreaElement(HTMLTextAreaElement), unHTMLTextAreaElement, castToHTMLTextAreaElement, gTypeHTMLTextAreaElement
-  , HTMLTitleElement(HTMLTitleElement), unHTMLTitleElement, castToHTMLTitleElement, gTypeHTMLTitleElement
-  , HTMLTrackElement(HTMLTrackElement), unHTMLTrackElement, castToHTMLTrackElement, gTypeHTMLTrackElement
-  , HTMLUListElement(HTMLUListElement), unHTMLUListElement, castToHTMLUListElement, gTypeHTMLUListElement
-  , HTMLUnknownElement(HTMLUnknownElement), unHTMLUnknownElement, castToHTMLUnknownElement, gTypeHTMLUnknownElement
-  , HTMLVideoElement(HTMLVideoElement), unHTMLVideoElement, castToHTMLVideoElement, gTypeHTMLVideoElement
-  , HashChangeEvent(HashChangeEvent), unHashChangeEvent, castToHashChangeEvent, gTypeHashChangeEvent
-  , History(History), unHistory, castToHistory, gTypeHistory
-  , IDBAny(IDBAny), unIDBAny, castToIDBAny, gTypeIDBAny
-  , IDBCursor(IDBCursor), unIDBCursor, IsIDBCursor, toIDBCursor, castToIDBCursor, gTypeIDBCursor
-  , IDBCursorWithValue(IDBCursorWithValue), unIDBCursorWithValue, castToIDBCursorWithValue, gTypeIDBCursorWithValue
-  , IDBDatabase(IDBDatabase), unIDBDatabase, castToIDBDatabase, gTypeIDBDatabase
-  , IDBFactory(IDBFactory), unIDBFactory, castToIDBFactory, gTypeIDBFactory
-  , IDBIndex(IDBIndex), unIDBIndex, castToIDBIndex, gTypeIDBIndex
-  , IDBKeyRange(IDBKeyRange), unIDBKeyRange, castToIDBKeyRange, gTypeIDBKeyRange
-  , IDBObjectStore(IDBObjectStore), unIDBObjectStore, castToIDBObjectStore, gTypeIDBObjectStore
-  , IDBOpenDBRequest(IDBOpenDBRequest), unIDBOpenDBRequest, castToIDBOpenDBRequest, gTypeIDBOpenDBRequest
-  , IDBRequest(IDBRequest), unIDBRequest, IsIDBRequest, toIDBRequest, castToIDBRequest, gTypeIDBRequest
-  , IDBTransaction(IDBTransaction), unIDBTransaction, castToIDBTransaction, gTypeIDBTransaction
-  , IDBVersionChangeEvent(IDBVersionChangeEvent), unIDBVersionChangeEvent, castToIDBVersionChangeEvent, gTypeIDBVersionChangeEvent
-  , ImageData(ImageData), unImageData, castToImageData, gTypeImageData
-  , InspectorFrontendHost(InspectorFrontendHost), unInspectorFrontendHost, castToInspectorFrontendHost, gTypeInspectorFrontendHost
-  , InternalSettings(InternalSettings), unInternalSettings, castToInternalSettings, gTypeInternalSettings
-  , Internals(Internals), unInternals, castToInternals, gTypeInternals
-  , KeyboardEvent(KeyboardEvent), unKeyboardEvent, castToKeyboardEvent, gTypeKeyboardEvent
-  , Location(Location), unLocation, castToLocation, gTypeLocation
-  , MallocStatistics(MallocStatistics), unMallocStatistics, castToMallocStatistics, gTypeMallocStatistics
-  , MediaController(MediaController), unMediaController, castToMediaController, gTypeMediaController
-  , MediaControlsHost(MediaControlsHost), unMediaControlsHost, castToMediaControlsHost, gTypeMediaControlsHost
-  , MediaElementAudioSourceNode(MediaElementAudioSourceNode), unMediaElementAudioSourceNode, castToMediaElementAudioSourceNode, gTypeMediaElementAudioSourceNode
-  , MediaError(MediaError), unMediaError, castToMediaError, gTypeMediaError
-  , MediaKeyError(MediaKeyError), unMediaKeyError, castToMediaKeyError, gTypeMediaKeyError
-  , MediaKeyEvent(MediaKeyEvent), unMediaKeyEvent, castToMediaKeyEvent, gTypeMediaKeyEvent
-  , MediaKeyMessageEvent(MediaKeyMessageEvent), unMediaKeyMessageEvent, castToMediaKeyMessageEvent, gTypeMediaKeyMessageEvent
-  , MediaKeyNeededEvent(MediaKeyNeededEvent), unMediaKeyNeededEvent, castToMediaKeyNeededEvent, gTypeMediaKeyNeededEvent
-  , MediaKeySession(MediaKeySession), unMediaKeySession, castToMediaKeySession, gTypeMediaKeySession
-  , MediaKeys(MediaKeys), unMediaKeys, castToMediaKeys, gTypeMediaKeys
-  , MediaList(MediaList), unMediaList, castToMediaList, gTypeMediaList
-  , MediaQueryList(MediaQueryList), unMediaQueryList, castToMediaQueryList, gTypeMediaQueryList
-  , MediaSource(MediaSource), unMediaSource, castToMediaSource, gTypeMediaSource
-  , MediaSourceStates(MediaSourceStates), unMediaSourceStates, castToMediaSourceStates, gTypeMediaSourceStates
-  , MediaStream(MediaStream), unMediaStream, castToMediaStream, gTypeMediaStream
-  , MediaStreamAudioDestinationNode(MediaStreamAudioDestinationNode), unMediaStreamAudioDestinationNode, castToMediaStreamAudioDestinationNode, gTypeMediaStreamAudioDestinationNode
-  , MediaStreamAudioSourceNode(MediaStreamAudioSourceNode), unMediaStreamAudioSourceNode, castToMediaStreamAudioSourceNode, gTypeMediaStreamAudioSourceNode
-  , MediaStreamCapabilities(MediaStreamCapabilities), unMediaStreamCapabilities, IsMediaStreamCapabilities, toMediaStreamCapabilities, castToMediaStreamCapabilities, gTypeMediaStreamCapabilities
-  , MediaStreamEvent(MediaStreamEvent), unMediaStreamEvent, castToMediaStreamEvent, gTypeMediaStreamEvent
-  , MediaStreamTrack(MediaStreamTrack), unMediaStreamTrack, IsMediaStreamTrack, toMediaStreamTrack, castToMediaStreamTrack, gTypeMediaStreamTrack
-  , MediaStreamTrackEvent(MediaStreamTrackEvent), unMediaStreamTrackEvent, castToMediaStreamTrackEvent, gTypeMediaStreamTrackEvent
-  , MediaTrackConstraint(MediaTrackConstraint), unMediaTrackConstraint, castToMediaTrackConstraint, gTypeMediaTrackConstraint
-  , MediaTrackConstraintSet(MediaTrackConstraintSet), unMediaTrackConstraintSet, castToMediaTrackConstraintSet, gTypeMediaTrackConstraintSet
-  , MediaTrackConstraints(MediaTrackConstraints), unMediaTrackConstraints, castToMediaTrackConstraints, gTypeMediaTrackConstraints
-  , MemoryInfo(MemoryInfo), unMemoryInfo, castToMemoryInfo, gTypeMemoryInfo
-  , MessageChannel(MessageChannel), unMessageChannel, castToMessageChannel, gTypeMessageChannel
-  , MessageEvent(MessageEvent), unMessageEvent, castToMessageEvent, gTypeMessageEvent
-  , MessagePort(MessagePort), unMessagePort, castToMessagePort, gTypeMessagePort
-  , MimeType(MimeType), unMimeType, castToMimeType, gTypeMimeType
-  , MimeTypeArray(MimeTypeArray), unMimeTypeArray, castToMimeTypeArray, gTypeMimeTypeArray
-  , MouseEvent(MouseEvent), unMouseEvent, IsMouseEvent, toMouseEvent, castToMouseEvent, gTypeMouseEvent
-  , MutationEvent(MutationEvent), unMutationEvent, castToMutationEvent, gTypeMutationEvent
-  , MutationObserver(MutationObserver), unMutationObserver, castToMutationObserver, gTypeMutationObserver
-  , MutationRecord(MutationRecord), unMutationRecord, castToMutationRecord, gTypeMutationRecord
-  , NamedNodeMap(NamedNodeMap), unNamedNodeMap, castToNamedNodeMap, gTypeNamedNodeMap
-  , Navigator(Navigator), unNavigator, castToNavigator, gTypeNavigator
-  , NavigatorUserMediaError(NavigatorUserMediaError), unNavigatorUserMediaError, castToNavigatorUserMediaError, gTypeNavigatorUserMediaError
-  , Node(Node), unNode, IsNode, toNode, castToNode, gTypeNode
-  , NodeFilter(NodeFilter), unNodeFilter, castToNodeFilter, gTypeNodeFilter
-  , NodeIterator(NodeIterator), unNodeIterator, castToNodeIterator, gTypeNodeIterator
-  , NodeList(NodeList), unNodeList, IsNodeList, toNodeList, castToNodeList, gTypeNodeList
-  , Notification(Notification), unNotification, castToNotification, gTypeNotification
-  , NotificationCenter(NotificationCenter), unNotificationCenter, castToNotificationCenter, gTypeNotificationCenter
-  , OESElementIndexUint(OESElementIndexUint), unOESElementIndexUint, castToOESElementIndexUint, gTypeOESElementIndexUint
-  , OESStandardDerivatives(OESStandardDerivatives), unOESStandardDerivatives, castToOESStandardDerivatives, gTypeOESStandardDerivatives
-  , OESTextureFloat(OESTextureFloat), unOESTextureFloat, castToOESTextureFloat, gTypeOESTextureFloat
-  , OESTextureFloatLinear(OESTextureFloatLinear), unOESTextureFloatLinear, castToOESTextureFloatLinear, gTypeOESTextureFloatLinear
-  , OESTextureHalfFloat(OESTextureHalfFloat), unOESTextureHalfFloat, castToOESTextureHalfFloat, gTypeOESTextureHalfFloat
-  , OESTextureHalfFloatLinear(OESTextureHalfFloatLinear), unOESTextureHalfFloatLinear, castToOESTextureHalfFloatLinear, gTypeOESTextureHalfFloatLinear
-  , OESVertexArrayObject(OESVertexArrayObject), unOESVertexArrayObject, castToOESVertexArrayObject, gTypeOESVertexArrayObject
-  , OfflineAudioCompletionEvent(OfflineAudioCompletionEvent), unOfflineAudioCompletionEvent, castToOfflineAudioCompletionEvent, gTypeOfflineAudioCompletionEvent
-  , OfflineAudioContext(OfflineAudioContext), unOfflineAudioContext, castToOfflineAudioContext, gTypeOfflineAudioContext
-  , OscillatorNode(OscillatorNode), unOscillatorNode, castToOscillatorNode, gTypeOscillatorNode
-  , OverflowEvent(OverflowEvent), unOverflowEvent, castToOverflowEvent, gTypeOverflowEvent
-  , PageTransitionEvent(PageTransitionEvent), unPageTransitionEvent, castToPageTransitionEvent, gTypePageTransitionEvent
-  , PannerNode(PannerNode), unPannerNode, castToPannerNode, gTypePannerNode
-  , Path2D(Path2D), unPath2D, castToPath2D, gTypePath2D
-  , Performance(Performance), unPerformance, castToPerformance, gTypePerformance
-  , PerformanceEntry(PerformanceEntry), unPerformanceEntry, IsPerformanceEntry, toPerformanceEntry, castToPerformanceEntry, gTypePerformanceEntry
-  , PerformanceEntryList(PerformanceEntryList), unPerformanceEntryList, castToPerformanceEntryList, gTypePerformanceEntryList
-  , PerformanceMark(PerformanceMark), unPerformanceMark, castToPerformanceMark, gTypePerformanceMark
-  , PerformanceMeasure(PerformanceMeasure), unPerformanceMeasure, castToPerformanceMeasure, gTypePerformanceMeasure
-  , PerformanceNavigation(PerformanceNavigation), unPerformanceNavigation, castToPerformanceNavigation, gTypePerformanceNavigation
-  , PerformanceResourceTiming(PerformanceResourceTiming), unPerformanceResourceTiming, castToPerformanceResourceTiming, gTypePerformanceResourceTiming
-  , PerformanceTiming(PerformanceTiming), unPerformanceTiming, castToPerformanceTiming, gTypePerformanceTiming
-  , PeriodicWave(PeriodicWave), unPeriodicWave, castToPeriodicWave, gTypePeriodicWave
-  , Plugin(Plugin), unPlugin, castToPlugin, gTypePlugin
-  , PluginArray(PluginArray), unPluginArray, castToPluginArray, gTypePluginArray
-  , PopStateEvent(PopStateEvent), unPopStateEvent, castToPopStateEvent, gTypePopStateEvent
-  , PositionError(PositionError), unPositionError, castToPositionError, gTypePositionError
-  , ProcessingInstruction(ProcessingInstruction), unProcessingInstruction, castToProcessingInstruction, gTypeProcessingInstruction
-  , ProgressEvent(ProgressEvent), unProgressEvent, IsProgressEvent, toProgressEvent, castToProgressEvent, gTypeProgressEvent
-  , QuickTimePluginReplacement(QuickTimePluginReplacement), unQuickTimePluginReplacement, castToQuickTimePluginReplacement, gTypeQuickTimePluginReplacement
-  , RGBColor(RGBColor), unRGBColor, castToRGBColor, gTypeRGBColor
-  , RTCConfiguration(RTCConfiguration), unRTCConfiguration, castToRTCConfiguration, gTypeRTCConfiguration
-  , RTCDTMFSender(RTCDTMFSender), unRTCDTMFSender, castToRTCDTMFSender, gTypeRTCDTMFSender
-  , RTCDTMFToneChangeEvent(RTCDTMFToneChangeEvent), unRTCDTMFToneChangeEvent, castToRTCDTMFToneChangeEvent, gTypeRTCDTMFToneChangeEvent
-  , RTCDataChannel(RTCDataChannel), unRTCDataChannel, castToRTCDataChannel, gTypeRTCDataChannel
-  , RTCDataChannelEvent(RTCDataChannelEvent), unRTCDataChannelEvent, castToRTCDataChannelEvent, gTypeRTCDataChannelEvent
-  , RTCIceCandidate(RTCIceCandidate), unRTCIceCandidate, castToRTCIceCandidate, gTypeRTCIceCandidate
-  , RTCIceCandidateEvent(RTCIceCandidateEvent), unRTCIceCandidateEvent, castToRTCIceCandidateEvent, gTypeRTCIceCandidateEvent
-  , RTCIceServer(RTCIceServer), unRTCIceServer, castToRTCIceServer, gTypeRTCIceServer
-  , RTCPeerConnection(RTCPeerConnection), unRTCPeerConnection, castToRTCPeerConnection, gTypeRTCPeerConnection
-  , RTCSessionDescription(RTCSessionDescription), unRTCSessionDescription, castToRTCSessionDescription, gTypeRTCSessionDescription
-  , RTCStatsReport(RTCStatsReport), unRTCStatsReport, castToRTCStatsReport, gTypeRTCStatsReport
-  , RTCStatsResponse(RTCStatsResponse), unRTCStatsResponse, castToRTCStatsResponse, gTypeRTCStatsResponse
-  , RadioNodeList(RadioNodeList), unRadioNodeList, castToRadioNodeList, gTypeRadioNodeList
-  , Range(Range), unRange, castToRange, gTypeRange
-  , ReadableStream(ReadableStream), unReadableStream, castToReadableStream, gTypeReadableStream
-  , Rect(Rect), unRect, castToRect, gTypeRect
-  , SQLError(SQLError), unSQLError, castToSQLError, gTypeSQLError
-  , SQLResultSet(SQLResultSet), unSQLResultSet, castToSQLResultSet, gTypeSQLResultSet
-  , SQLResultSetRowList(SQLResultSetRowList), unSQLResultSetRowList, castToSQLResultSetRowList, gTypeSQLResultSetRowList
-  , SQLTransaction(SQLTransaction), unSQLTransaction, castToSQLTransaction, gTypeSQLTransaction
-  , SVGAElement(SVGAElement), unSVGAElement, castToSVGAElement, gTypeSVGAElement
-  , SVGAltGlyphDefElement(SVGAltGlyphDefElement), unSVGAltGlyphDefElement, castToSVGAltGlyphDefElement, gTypeSVGAltGlyphDefElement
-  , SVGAltGlyphElement(SVGAltGlyphElement), unSVGAltGlyphElement, castToSVGAltGlyphElement, gTypeSVGAltGlyphElement
-  , SVGAltGlyphItemElement(SVGAltGlyphItemElement), unSVGAltGlyphItemElement, castToSVGAltGlyphItemElement, gTypeSVGAltGlyphItemElement
-  , SVGAngle(SVGAngle), unSVGAngle, castToSVGAngle, gTypeSVGAngle
-  , SVGAnimateColorElement(SVGAnimateColorElement), unSVGAnimateColorElement, castToSVGAnimateColorElement, gTypeSVGAnimateColorElement
-  , SVGAnimateElement(SVGAnimateElement), unSVGAnimateElement, castToSVGAnimateElement, gTypeSVGAnimateElement
-  , SVGAnimateMotionElement(SVGAnimateMotionElement), unSVGAnimateMotionElement, castToSVGAnimateMotionElement, gTypeSVGAnimateMotionElement
-  , SVGAnimateTransformElement(SVGAnimateTransformElement), unSVGAnimateTransformElement, castToSVGAnimateTransformElement, gTypeSVGAnimateTransformElement
-  , SVGAnimatedAngle(SVGAnimatedAngle), unSVGAnimatedAngle, castToSVGAnimatedAngle, gTypeSVGAnimatedAngle
-  , SVGAnimatedBoolean(SVGAnimatedBoolean), unSVGAnimatedBoolean, castToSVGAnimatedBoolean, gTypeSVGAnimatedBoolean
-  , SVGAnimatedEnumeration(SVGAnimatedEnumeration), unSVGAnimatedEnumeration, castToSVGAnimatedEnumeration, gTypeSVGAnimatedEnumeration
-  , SVGAnimatedInteger(SVGAnimatedInteger), unSVGAnimatedInteger, castToSVGAnimatedInteger, gTypeSVGAnimatedInteger
-  , SVGAnimatedLength(SVGAnimatedLength), unSVGAnimatedLength, castToSVGAnimatedLength, gTypeSVGAnimatedLength
-  , SVGAnimatedLengthList(SVGAnimatedLengthList), unSVGAnimatedLengthList, castToSVGAnimatedLengthList, gTypeSVGAnimatedLengthList
-  , SVGAnimatedNumber(SVGAnimatedNumber), unSVGAnimatedNumber, castToSVGAnimatedNumber, gTypeSVGAnimatedNumber
-  , SVGAnimatedNumberList(SVGAnimatedNumberList), unSVGAnimatedNumberList, castToSVGAnimatedNumberList, gTypeSVGAnimatedNumberList
-  , SVGAnimatedPreserveAspectRatio(SVGAnimatedPreserveAspectRatio), unSVGAnimatedPreserveAspectRatio, castToSVGAnimatedPreserveAspectRatio, gTypeSVGAnimatedPreserveAspectRatio
-  , SVGAnimatedRect(SVGAnimatedRect), unSVGAnimatedRect, castToSVGAnimatedRect, gTypeSVGAnimatedRect
-  , SVGAnimatedString(SVGAnimatedString), unSVGAnimatedString, castToSVGAnimatedString, gTypeSVGAnimatedString
-  , SVGAnimatedTransformList(SVGAnimatedTransformList), unSVGAnimatedTransformList, castToSVGAnimatedTransformList, gTypeSVGAnimatedTransformList
-  , SVGAnimationElement(SVGAnimationElement), unSVGAnimationElement, IsSVGAnimationElement, toSVGAnimationElement, castToSVGAnimationElement, gTypeSVGAnimationElement
-  , SVGCircleElement(SVGCircleElement), unSVGCircleElement, castToSVGCircleElement, gTypeSVGCircleElement
-  , SVGClipPathElement(SVGClipPathElement), unSVGClipPathElement, castToSVGClipPathElement, gTypeSVGClipPathElement
-  , SVGColor(SVGColor), unSVGColor, IsSVGColor, toSVGColor, castToSVGColor, gTypeSVGColor
-  , SVGComponentTransferFunctionElement(SVGComponentTransferFunctionElement), unSVGComponentTransferFunctionElement, IsSVGComponentTransferFunctionElement, toSVGComponentTransferFunctionElement, castToSVGComponentTransferFunctionElement, gTypeSVGComponentTransferFunctionElement
-  , SVGCursorElement(SVGCursorElement), unSVGCursorElement, castToSVGCursorElement, gTypeSVGCursorElement
-  , SVGDefsElement(SVGDefsElement), unSVGDefsElement, castToSVGDefsElement, gTypeSVGDefsElement
-  , SVGDescElement(SVGDescElement), unSVGDescElement, castToSVGDescElement, gTypeSVGDescElement
-  , SVGDocument(SVGDocument), unSVGDocument, castToSVGDocument, gTypeSVGDocument
-  , SVGElement(SVGElement), unSVGElement, IsSVGElement, toSVGElement, castToSVGElement, gTypeSVGElement
-  , SVGEllipseElement(SVGEllipseElement), unSVGEllipseElement, castToSVGEllipseElement, gTypeSVGEllipseElement
-  , SVGExternalResourcesRequired(SVGExternalResourcesRequired), unSVGExternalResourcesRequired, castToSVGExternalResourcesRequired, gTypeSVGExternalResourcesRequired
-  , SVGFEBlendElement(SVGFEBlendElement), unSVGFEBlendElement, castToSVGFEBlendElement, gTypeSVGFEBlendElement
-  , SVGFEColorMatrixElement(SVGFEColorMatrixElement), unSVGFEColorMatrixElement, castToSVGFEColorMatrixElement, gTypeSVGFEColorMatrixElement
-  , SVGFEComponentTransferElement(SVGFEComponentTransferElement), unSVGFEComponentTransferElement, castToSVGFEComponentTransferElement, gTypeSVGFEComponentTransferElement
-  , SVGFECompositeElement(SVGFECompositeElement), unSVGFECompositeElement, castToSVGFECompositeElement, gTypeSVGFECompositeElement
-  , SVGFEConvolveMatrixElement(SVGFEConvolveMatrixElement), unSVGFEConvolveMatrixElement, castToSVGFEConvolveMatrixElement, gTypeSVGFEConvolveMatrixElement
-  , SVGFEDiffuseLightingElement(SVGFEDiffuseLightingElement), unSVGFEDiffuseLightingElement, castToSVGFEDiffuseLightingElement, gTypeSVGFEDiffuseLightingElement
-  , SVGFEDisplacementMapElement(SVGFEDisplacementMapElement), unSVGFEDisplacementMapElement, castToSVGFEDisplacementMapElement, gTypeSVGFEDisplacementMapElement
-  , SVGFEDistantLightElement(SVGFEDistantLightElement), unSVGFEDistantLightElement, castToSVGFEDistantLightElement, gTypeSVGFEDistantLightElement
-  , SVGFEDropShadowElement(SVGFEDropShadowElement), unSVGFEDropShadowElement, castToSVGFEDropShadowElement, gTypeSVGFEDropShadowElement
-  , SVGFEFloodElement(SVGFEFloodElement), unSVGFEFloodElement, castToSVGFEFloodElement, gTypeSVGFEFloodElement
-  , SVGFEFuncAElement(SVGFEFuncAElement), unSVGFEFuncAElement, castToSVGFEFuncAElement, gTypeSVGFEFuncAElement
-  , SVGFEFuncBElement(SVGFEFuncBElement), unSVGFEFuncBElement, castToSVGFEFuncBElement, gTypeSVGFEFuncBElement
-  , SVGFEFuncGElement(SVGFEFuncGElement), unSVGFEFuncGElement, castToSVGFEFuncGElement, gTypeSVGFEFuncGElement
-  , SVGFEFuncRElement(SVGFEFuncRElement), unSVGFEFuncRElement, castToSVGFEFuncRElement, gTypeSVGFEFuncRElement
-  , SVGFEGaussianBlurElement(SVGFEGaussianBlurElement), unSVGFEGaussianBlurElement, castToSVGFEGaussianBlurElement, gTypeSVGFEGaussianBlurElement
-  , SVGFEImageElement(SVGFEImageElement), unSVGFEImageElement, castToSVGFEImageElement, gTypeSVGFEImageElement
-  , SVGFEMergeElement(SVGFEMergeElement), unSVGFEMergeElement, castToSVGFEMergeElement, gTypeSVGFEMergeElement
-  , SVGFEMergeNodeElement(SVGFEMergeNodeElement), unSVGFEMergeNodeElement, castToSVGFEMergeNodeElement, gTypeSVGFEMergeNodeElement
-  , SVGFEMorphologyElement(SVGFEMorphologyElement), unSVGFEMorphologyElement, castToSVGFEMorphologyElement, gTypeSVGFEMorphologyElement
-  , SVGFEOffsetElement(SVGFEOffsetElement), unSVGFEOffsetElement, castToSVGFEOffsetElement, gTypeSVGFEOffsetElement
-  , SVGFEPointLightElement(SVGFEPointLightElement), unSVGFEPointLightElement, castToSVGFEPointLightElement, gTypeSVGFEPointLightElement
-  , SVGFESpecularLightingElement(SVGFESpecularLightingElement), unSVGFESpecularLightingElement, castToSVGFESpecularLightingElement, gTypeSVGFESpecularLightingElement
-  , SVGFESpotLightElement(SVGFESpotLightElement), unSVGFESpotLightElement, castToSVGFESpotLightElement, gTypeSVGFESpotLightElement
-  , SVGFETileElement(SVGFETileElement), unSVGFETileElement, castToSVGFETileElement, gTypeSVGFETileElement
-  , SVGFETurbulenceElement(SVGFETurbulenceElement), unSVGFETurbulenceElement, castToSVGFETurbulenceElement, gTypeSVGFETurbulenceElement
-  , SVGFilterElement(SVGFilterElement), unSVGFilterElement, castToSVGFilterElement, gTypeSVGFilterElement
-  , SVGFilterPrimitiveStandardAttributes(SVGFilterPrimitiveStandardAttributes), unSVGFilterPrimitiveStandardAttributes, castToSVGFilterPrimitiveStandardAttributes, gTypeSVGFilterPrimitiveStandardAttributes
-  , SVGFitToViewBox(SVGFitToViewBox), unSVGFitToViewBox, castToSVGFitToViewBox, gTypeSVGFitToViewBox
-  , SVGFontElement(SVGFontElement), unSVGFontElement, castToSVGFontElement, gTypeSVGFontElement
-  , SVGFontFaceElement(SVGFontFaceElement), unSVGFontFaceElement, castToSVGFontFaceElement, gTypeSVGFontFaceElement
-  , SVGFontFaceFormatElement(SVGFontFaceFormatElement), unSVGFontFaceFormatElement, castToSVGFontFaceFormatElement, gTypeSVGFontFaceFormatElement
-  , SVGFontFaceNameElement(SVGFontFaceNameElement), unSVGFontFaceNameElement, castToSVGFontFaceNameElement, gTypeSVGFontFaceNameElement
-  , SVGFontFaceSrcElement(SVGFontFaceSrcElement), unSVGFontFaceSrcElement, castToSVGFontFaceSrcElement, gTypeSVGFontFaceSrcElement
-  , SVGFontFaceUriElement(SVGFontFaceUriElement), unSVGFontFaceUriElement, castToSVGFontFaceUriElement, gTypeSVGFontFaceUriElement
-  , SVGForeignObjectElement(SVGForeignObjectElement), unSVGForeignObjectElement, castToSVGForeignObjectElement, gTypeSVGForeignObjectElement
-  , SVGGElement(SVGGElement), unSVGGElement, castToSVGGElement, gTypeSVGGElement
-  , SVGGlyphElement(SVGGlyphElement), unSVGGlyphElement, castToSVGGlyphElement, gTypeSVGGlyphElement
-  , SVGGlyphRefElement(SVGGlyphRefElement), unSVGGlyphRefElement, castToSVGGlyphRefElement, gTypeSVGGlyphRefElement
-  , SVGGradientElement(SVGGradientElement), unSVGGradientElement, IsSVGGradientElement, toSVGGradientElement, castToSVGGradientElement, gTypeSVGGradientElement
-  , SVGGraphicsElement(SVGGraphicsElement), unSVGGraphicsElement, IsSVGGraphicsElement, toSVGGraphicsElement, castToSVGGraphicsElement, gTypeSVGGraphicsElement
-  , SVGHKernElement(SVGHKernElement), unSVGHKernElement, castToSVGHKernElement, gTypeSVGHKernElement
-  , SVGImageElement(SVGImageElement), unSVGImageElement, castToSVGImageElement, gTypeSVGImageElement
-  , SVGLength(SVGLength), unSVGLength, castToSVGLength, gTypeSVGLength
-  , SVGLengthList(SVGLengthList), unSVGLengthList, castToSVGLengthList, gTypeSVGLengthList
-  , SVGLineElement(SVGLineElement), unSVGLineElement, castToSVGLineElement, gTypeSVGLineElement
-  , SVGLinearGradientElement(SVGLinearGradientElement), unSVGLinearGradientElement, castToSVGLinearGradientElement, gTypeSVGLinearGradientElement
-  , SVGMPathElement(SVGMPathElement), unSVGMPathElement, castToSVGMPathElement, gTypeSVGMPathElement
-  , SVGMarkerElement(SVGMarkerElement), unSVGMarkerElement, castToSVGMarkerElement, gTypeSVGMarkerElement
-  , SVGMaskElement(SVGMaskElement), unSVGMaskElement, castToSVGMaskElement, gTypeSVGMaskElement
-  , SVGMatrix(SVGMatrix), unSVGMatrix, castToSVGMatrix, gTypeSVGMatrix
-  , SVGMetadataElement(SVGMetadataElement), unSVGMetadataElement, castToSVGMetadataElement, gTypeSVGMetadataElement
-  , SVGMissingGlyphElement(SVGMissingGlyphElement), unSVGMissingGlyphElement, castToSVGMissingGlyphElement, gTypeSVGMissingGlyphElement
-  , SVGNumber(SVGNumber), unSVGNumber, castToSVGNumber, gTypeSVGNumber
-  , SVGNumberList(SVGNumberList), unSVGNumberList, castToSVGNumberList, gTypeSVGNumberList
-  , SVGPaint(SVGPaint), unSVGPaint, castToSVGPaint, gTypeSVGPaint
-  , SVGPathElement(SVGPathElement), unSVGPathElement, castToSVGPathElement, gTypeSVGPathElement
-  , SVGPathSeg(SVGPathSeg), unSVGPathSeg, IsSVGPathSeg, toSVGPathSeg, castToSVGPathSeg, gTypeSVGPathSeg
-  , SVGPathSegArcAbs(SVGPathSegArcAbs), unSVGPathSegArcAbs, castToSVGPathSegArcAbs, gTypeSVGPathSegArcAbs
-  , SVGPathSegArcRel(SVGPathSegArcRel), unSVGPathSegArcRel, castToSVGPathSegArcRel, gTypeSVGPathSegArcRel
-  , SVGPathSegClosePath(SVGPathSegClosePath), unSVGPathSegClosePath, castToSVGPathSegClosePath, gTypeSVGPathSegClosePath
-  , SVGPathSegCurvetoCubicAbs(SVGPathSegCurvetoCubicAbs), unSVGPathSegCurvetoCubicAbs, castToSVGPathSegCurvetoCubicAbs, gTypeSVGPathSegCurvetoCubicAbs
-  , SVGPathSegCurvetoCubicRel(SVGPathSegCurvetoCubicRel), unSVGPathSegCurvetoCubicRel, castToSVGPathSegCurvetoCubicRel, gTypeSVGPathSegCurvetoCubicRel
-  , SVGPathSegCurvetoCubicSmoothAbs(SVGPathSegCurvetoCubicSmoothAbs), unSVGPathSegCurvetoCubicSmoothAbs, castToSVGPathSegCurvetoCubicSmoothAbs, gTypeSVGPathSegCurvetoCubicSmoothAbs
-  , SVGPathSegCurvetoCubicSmoothRel(SVGPathSegCurvetoCubicSmoothRel), unSVGPathSegCurvetoCubicSmoothRel, castToSVGPathSegCurvetoCubicSmoothRel, gTypeSVGPathSegCurvetoCubicSmoothRel
-  , SVGPathSegCurvetoQuadraticAbs(SVGPathSegCurvetoQuadraticAbs), unSVGPathSegCurvetoQuadraticAbs, castToSVGPathSegCurvetoQuadraticAbs, gTypeSVGPathSegCurvetoQuadraticAbs
-  , SVGPathSegCurvetoQuadraticRel(SVGPathSegCurvetoQuadraticRel), unSVGPathSegCurvetoQuadraticRel, castToSVGPathSegCurvetoQuadraticRel, gTypeSVGPathSegCurvetoQuadraticRel
-  , SVGPathSegCurvetoQuadraticSmoothAbs(SVGPathSegCurvetoQuadraticSmoothAbs), unSVGPathSegCurvetoQuadraticSmoothAbs, castToSVGPathSegCurvetoQuadraticSmoothAbs, gTypeSVGPathSegCurvetoQuadraticSmoothAbs
-  , SVGPathSegCurvetoQuadraticSmoothRel(SVGPathSegCurvetoQuadraticSmoothRel), unSVGPathSegCurvetoQuadraticSmoothRel, castToSVGPathSegCurvetoQuadraticSmoothRel, gTypeSVGPathSegCurvetoQuadraticSmoothRel
-  , SVGPathSegLinetoAbs(SVGPathSegLinetoAbs), unSVGPathSegLinetoAbs, castToSVGPathSegLinetoAbs, gTypeSVGPathSegLinetoAbs
-  , SVGPathSegLinetoHorizontalAbs(SVGPathSegLinetoHorizontalAbs), unSVGPathSegLinetoHorizontalAbs, castToSVGPathSegLinetoHorizontalAbs, gTypeSVGPathSegLinetoHorizontalAbs
-  , SVGPathSegLinetoHorizontalRel(SVGPathSegLinetoHorizontalRel), unSVGPathSegLinetoHorizontalRel, castToSVGPathSegLinetoHorizontalRel, gTypeSVGPathSegLinetoHorizontalRel
-  , SVGPathSegLinetoRel(SVGPathSegLinetoRel), unSVGPathSegLinetoRel, castToSVGPathSegLinetoRel, gTypeSVGPathSegLinetoRel
-  , SVGPathSegLinetoVerticalAbs(SVGPathSegLinetoVerticalAbs), unSVGPathSegLinetoVerticalAbs, castToSVGPathSegLinetoVerticalAbs, gTypeSVGPathSegLinetoVerticalAbs
-  , SVGPathSegLinetoVerticalRel(SVGPathSegLinetoVerticalRel), unSVGPathSegLinetoVerticalRel, castToSVGPathSegLinetoVerticalRel, gTypeSVGPathSegLinetoVerticalRel
-  , SVGPathSegList(SVGPathSegList), unSVGPathSegList, castToSVGPathSegList, gTypeSVGPathSegList
-  , SVGPathSegMovetoAbs(SVGPathSegMovetoAbs), unSVGPathSegMovetoAbs, castToSVGPathSegMovetoAbs, gTypeSVGPathSegMovetoAbs
-  , SVGPathSegMovetoRel(SVGPathSegMovetoRel), unSVGPathSegMovetoRel, castToSVGPathSegMovetoRel, gTypeSVGPathSegMovetoRel
-  , SVGPatternElement(SVGPatternElement), unSVGPatternElement, castToSVGPatternElement, gTypeSVGPatternElement
-  , SVGPoint(SVGPoint), unSVGPoint, castToSVGPoint, gTypeSVGPoint
-  , SVGPointList(SVGPointList), unSVGPointList, castToSVGPointList, gTypeSVGPointList
-  , SVGPolygonElement(SVGPolygonElement), unSVGPolygonElement, castToSVGPolygonElement, gTypeSVGPolygonElement
-  , SVGPolylineElement(SVGPolylineElement), unSVGPolylineElement, castToSVGPolylineElement, gTypeSVGPolylineElement
-  , SVGPreserveAspectRatio(SVGPreserveAspectRatio), unSVGPreserveAspectRatio, castToSVGPreserveAspectRatio, gTypeSVGPreserveAspectRatio
-  , SVGRadialGradientElement(SVGRadialGradientElement), unSVGRadialGradientElement, castToSVGRadialGradientElement, gTypeSVGRadialGradientElement
-  , SVGRect(SVGRect), unSVGRect, castToSVGRect, gTypeSVGRect
-  , SVGRectElement(SVGRectElement), unSVGRectElement, castToSVGRectElement, gTypeSVGRectElement
-  , SVGRenderingIntent(SVGRenderingIntent), unSVGRenderingIntent, castToSVGRenderingIntent, gTypeSVGRenderingIntent
-  , SVGSVGElement(SVGSVGElement), unSVGSVGElement, castToSVGSVGElement, gTypeSVGSVGElement
-  , SVGScriptElement(SVGScriptElement), unSVGScriptElement, castToSVGScriptElement, gTypeSVGScriptElement
-  , SVGSetElement(SVGSetElement), unSVGSetElement, castToSVGSetElement, gTypeSVGSetElement
-  , SVGStopElement(SVGStopElement), unSVGStopElement, castToSVGStopElement, gTypeSVGStopElement
-  , SVGStringList(SVGStringList), unSVGStringList, castToSVGStringList, gTypeSVGStringList
-  , SVGStyleElement(SVGStyleElement), unSVGStyleElement, castToSVGStyleElement, gTypeSVGStyleElement
-  , SVGSwitchElement(SVGSwitchElement), unSVGSwitchElement, castToSVGSwitchElement, gTypeSVGSwitchElement
-  , SVGSymbolElement(SVGSymbolElement), unSVGSymbolElement, castToSVGSymbolElement, gTypeSVGSymbolElement
-  , SVGTRefElement(SVGTRefElement), unSVGTRefElement, castToSVGTRefElement, gTypeSVGTRefElement
-  , SVGTSpanElement(SVGTSpanElement), unSVGTSpanElement, castToSVGTSpanElement, gTypeSVGTSpanElement
-  , SVGTests(SVGTests), unSVGTests, castToSVGTests, gTypeSVGTests
-  , SVGTextContentElement(SVGTextContentElement), unSVGTextContentElement, IsSVGTextContentElement, toSVGTextContentElement, castToSVGTextContentElement, gTypeSVGTextContentElement
-  , SVGTextElement(SVGTextElement), unSVGTextElement, castToSVGTextElement, gTypeSVGTextElement
-  , SVGTextPathElement(SVGTextPathElement), unSVGTextPathElement, castToSVGTextPathElement, gTypeSVGTextPathElement
-  , SVGTextPositioningElement(SVGTextPositioningElement), unSVGTextPositioningElement, IsSVGTextPositioningElement, toSVGTextPositioningElement, castToSVGTextPositioningElement, gTypeSVGTextPositioningElement
-  , SVGTitleElement(SVGTitleElement), unSVGTitleElement, castToSVGTitleElement, gTypeSVGTitleElement
-  , SVGTransform(SVGTransform), unSVGTransform, castToSVGTransform, gTypeSVGTransform
-  , SVGTransformList(SVGTransformList), unSVGTransformList, castToSVGTransformList, gTypeSVGTransformList
-  , SVGURIReference(SVGURIReference), unSVGURIReference, castToSVGURIReference, gTypeSVGURIReference
-  , SVGUnitTypes(SVGUnitTypes), unSVGUnitTypes, castToSVGUnitTypes, gTypeSVGUnitTypes
-  , SVGUseElement(SVGUseElement), unSVGUseElement, castToSVGUseElement, gTypeSVGUseElement
-  , SVGVKernElement(SVGVKernElement), unSVGVKernElement, castToSVGVKernElement, gTypeSVGVKernElement
-  , SVGViewElement(SVGViewElement), unSVGViewElement, castToSVGViewElement, gTypeSVGViewElement
-  , SVGViewSpec(SVGViewSpec), unSVGViewSpec, castToSVGViewSpec, gTypeSVGViewSpec
-  , SVGZoomAndPan(SVGZoomAndPan), unSVGZoomAndPan, castToSVGZoomAndPan, gTypeSVGZoomAndPan
-  , SVGZoomEvent(SVGZoomEvent), unSVGZoomEvent, castToSVGZoomEvent, gTypeSVGZoomEvent
-  , Screen(Screen), unScreen, castToScreen, gTypeScreen
-  , ScriptProcessorNode(ScriptProcessorNode), unScriptProcessorNode, castToScriptProcessorNode, gTypeScriptProcessorNode
-  , ScriptProfile(ScriptProfile), unScriptProfile, castToScriptProfile, gTypeScriptProfile
-  , ScriptProfileNode(ScriptProfileNode), unScriptProfileNode, castToScriptProfileNode, gTypeScriptProfileNode
-  , SecurityPolicy(SecurityPolicy), unSecurityPolicy, castToSecurityPolicy, gTypeSecurityPolicy
-  , SecurityPolicyViolationEvent(SecurityPolicyViolationEvent), unSecurityPolicyViolationEvent, castToSecurityPolicyViolationEvent, gTypeSecurityPolicyViolationEvent
-  , Selection(Selection), unSelection, castToSelection, gTypeSelection
-  , SourceBuffer(SourceBuffer), unSourceBuffer, castToSourceBuffer, gTypeSourceBuffer
-  , SourceBufferList(SourceBufferList), unSourceBufferList, castToSourceBufferList, gTypeSourceBufferList
-  , SourceInfo(SourceInfo), unSourceInfo, castToSourceInfo, gTypeSourceInfo
-  , SpeechSynthesis(SpeechSynthesis), unSpeechSynthesis, castToSpeechSynthesis, gTypeSpeechSynthesis
-  , SpeechSynthesisEvent(SpeechSynthesisEvent), unSpeechSynthesisEvent, castToSpeechSynthesisEvent, gTypeSpeechSynthesisEvent
-  , SpeechSynthesisUtterance(SpeechSynthesisUtterance), unSpeechSynthesisUtterance, castToSpeechSynthesisUtterance, gTypeSpeechSynthesisUtterance
-  , SpeechSynthesisVoice(SpeechSynthesisVoice), unSpeechSynthesisVoice, castToSpeechSynthesisVoice, gTypeSpeechSynthesisVoice
-  , Storage(Storage), unStorage, castToStorage, gTypeStorage
-  , StorageEvent(StorageEvent), unStorageEvent, castToStorageEvent, gTypeStorageEvent
-  , StorageInfo(StorageInfo), unStorageInfo, castToStorageInfo, gTypeStorageInfo
-  , StorageQuota(StorageQuota), unStorageQuota, castToStorageQuota, gTypeStorageQuota
-  , StyleMedia(StyleMedia), unStyleMedia, castToStyleMedia, gTypeStyleMedia
-  , StyleSheet(StyleSheet), unStyleSheet, IsStyleSheet, toStyleSheet, castToStyleSheet, gTypeStyleSheet
-  , StyleSheetList(StyleSheetList), unStyleSheetList, castToStyleSheetList, gTypeStyleSheetList
-  , SubtleCrypto(SubtleCrypto), unSubtleCrypto, castToSubtleCrypto, gTypeSubtleCrypto
-  , Text(Text), unText, IsText, toText, castToText, gTypeText
-  , TextEvent(TextEvent), unTextEvent, castToTextEvent, gTypeTextEvent
-  , TextMetrics(TextMetrics), unTextMetrics, castToTextMetrics, gTypeTextMetrics
-  , TextTrack(TextTrack), unTextTrack, castToTextTrack, gTypeTextTrack
-  , TextTrackCue(TextTrackCue), unTextTrackCue, IsTextTrackCue, toTextTrackCue, castToTextTrackCue, gTypeTextTrackCue
-  , TextTrackCueList(TextTrackCueList), unTextTrackCueList, castToTextTrackCueList, gTypeTextTrackCueList
-  , TextTrackList(TextTrackList), unTextTrackList, castToTextTrackList, gTypeTextTrackList
-  , TimeRanges(TimeRanges), unTimeRanges, castToTimeRanges, gTypeTimeRanges
-  , Touch(Touch), unTouch, castToTouch, gTypeTouch
-  , TouchEvent(TouchEvent), unTouchEvent, castToTouchEvent, gTypeTouchEvent
-  , TouchList(TouchList), unTouchList, castToTouchList, gTypeTouchList
-  , TrackEvent(TrackEvent), unTrackEvent, castToTrackEvent, gTypeTrackEvent
-  , TransitionEvent(TransitionEvent), unTransitionEvent, castToTransitionEvent, gTypeTransitionEvent
-  , TreeWalker(TreeWalker), unTreeWalker, castToTreeWalker, gTypeTreeWalker
-  , TypeConversions(TypeConversions), unTypeConversions, castToTypeConversions, gTypeTypeConversions
-  , UIEvent(UIEvent), unUIEvent, IsUIEvent, toUIEvent, castToUIEvent, gTypeUIEvent
-  , UIRequestEvent(UIRequestEvent), unUIRequestEvent, castToUIRequestEvent, gTypeUIRequestEvent
-  , URL(URL), unURL, castToURL, gTypeURL
-  , URLUtils(URLUtils), unURLUtils, castToURLUtils, gTypeURLUtils
-  , UserMessageHandler(UserMessageHandler), unUserMessageHandler, castToUserMessageHandler, gTypeUserMessageHandler
-  , UserMessageHandlersNamespace(UserMessageHandlersNamespace), unUserMessageHandlersNamespace, castToUserMessageHandlersNamespace, gTypeUserMessageHandlersNamespace
-  , VTTCue(VTTCue), unVTTCue, castToVTTCue, gTypeVTTCue
-  , VTTRegion(VTTRegion), unVTTRegion, castToVTTRegion, gTypeVTTRegion
-  , VTTRegionList(VTTRegionList), unVTTRegionList, castToVTTRegionList, gTypeVTTRegionList
-  , ValidityState(ValidityState), unValidityState, castToValidityState, gTypeValidityState
-  , VideoPlaybackQuality(VideoPlaybackQuality), unVideoPlaybackQuality, castToVideoPlaybackQuality, gTypeVideoPlaybackQuality
-  , VideoStreamTrack(VideoStreamTrack), unVideoStreamTrack, castToVideoStreamTrack, gTypeVideoStreamTrack
-  , VideoTrack(VideoTrack), unVideoTrack, castToVideoTrack, gTypeVideoTrack
-  , VideoTrackList(VideoTrackList), unVideoTrackList, castToVideoTrackList, gTypeVideoTrackList
-  , WaveShaperNode(WaveShaperNode), unWaveShaperNode, castToWaveShaperNode, gTypeWaveShaperNode
-  , WebGL2RenderingContext(WebGL2RenderingContext), unWebGL2RenderingContext, castToWebGL2RenderingContext, gTypeWebGL2RenderingContext
-  , WebGLActiveInfo(WebGLActiveInfo), unWebGLActiveInfo, castToWebGLActiveInfo, gTypeWebGLActiveInfo
-  , WebGLBuffer(WebGLBuffer), unWebGLBuffer, castToWebGLBuffer, gTypeWebGLBuffer
-  , WebGLCompressedTextureATC(WebGLCompressedTextureATC), unWebGLCompressedTextureATC, castToWebGLCompressedTextureATC, gTypeWebGLCompressedTextureATC
-  , WebGLCompressedTexturePVRTC(WebGLCompressedTexturePVRTC), unWebGLCompressedTexturePVRTC, castToWebGLCompressedTexturePVRTC, gTypeWebGLCompressedTexturePVRTC
-  , WebGLCompressedTextureS3TC(WebGLCompressedTextureS3TC), unWebGLCompressedTextureS3TC, castToWebGLCompressedTextureS3TC, gTypeWebGLCompressedTextureS3TC
-  , WebGLContextAttributes(WebGLContextAttributes), unWebGLContextAttributes, castToWebGLContextAttributes, gTypeWebGLContextAttributes
-  , WebGLContextEvent(WebGLContextEvent), unWebGLContextEvent, castToWebGLContextEvent, gTypeWebGLContextEvent
-  , WebGLDebugRendererInfo(WebGLDebugRendererInfo), unWebGLDebugRendererInfo, castToWebGLDebugRendererInfo, gTypeWebGLDebugRendererInfo
-  , WebGLDebugShaders(WebGLDebugShaders), unWebGLDebugShaders, castToWebGLDebugShaders, gTypeWebGLDebugShaders
-  , WebGLDepthTexture(WebGLDepthTexture), unWebGLDepthTexture, castToWebGLDepthTexture, gTypeWebGLDepthTexture
-  , WebGLDrawBuffers(WebGLDrawBuffers), unWebGLDrawBuffers, castToWebGLDrawBuffers, gTypeWebGLDrawBuffers
-  , WebGLFramebuffer(WebGLFramebuffer), unWebGLFramebuffer, castToWebGLFramebuffer, gTypeWebGLFramebuffer
-  , WebGLLoseContext(WebGLLoseContext), unWebGLLoseContext, castToWebGLLoseContext, gTypeWebGLLoseContext
-  , WebGLProgram(WebGLProgram), unWebGLProgram, castToWebGLProgram, gTypeWebGLProgram
-  , WebGLQuery(WebGLQuery), unWebGLQuery, castToWebGLQuery, gTypeWebGLQuery
-  , WebGLRenderbuffer(WebGLRenderbuffer), unWebGLRenderbuffer, castToWebGLRenderbuffer, gTypeWebGLRenderbuffer
-  , WebGLRenderingContext(WebGLRenderingContext), unWebGLRenderingContext, castToWebGLRenderingContext, gTypeWebGLRenderingContext
-  , WebGLRenderingContextBase(WebGLRenderingContextBase), unWebGLRenderingContextBase, IsWebGLRenderingContextBase, toWebGLRenderingContextBase, castToWebGLRenderingContextBase, gTypeWebGLRenderingContextBase
-  , WebGLSampler(WebGLSampler), unWebGLSampler, castToWebGLSampler, gTypeWebGLSampler
-  , WebGLShader(WebGLShader), unWebGLShader, castToWebGLShader, gTypeWebGLShader
-  , WebGLShaderPrecisionFormat(WebGLShaderPrecisionFormat), unWebGLShaderPrecisionFormat, castToWebGLShaderPrecisionFormat, gTypeWebGLShaderPrecisionFormat
-  , WebGLSync(WebGLSync), unWebGLSync, castToWebGLSync, gTypeWebGLSync
-  , WebGLTexture(WebGLTexture), unWebGLTexture, castToWebGLTexture, gTypeWebGLTexture
-  , WebGLTransformFeedback(WebGLTransformFeedback), unWebGLTransformFeedback, castToWebGLTransformFeedback, gTypeWebGLTransformFeedback
-  , WebGLUniformLocation(WebGLUniformLocation), unWebGLUniformLocation, castToWebGLUniformLocation, gTypeWebGLUniformLocation
-  , WebGLVertexArrayObject(WebGLVertexArrayObject), unWebGLVertexArrayObject, castToWebGLVertexArrayObject, gTypeWebGLVertexArrayObject
-  , WebGLVertexArrayObjectOES(WebGLVertexArrayObjectOES), unWebGLVertexArrayObjectOES, castToWebGLVertexArrayObjectOES, gTypeWebGLVertexArrayObjectOES
-  , WebKitAnimationEvent(WebKitAnimationEvent), unWebKitAnimationEvent, castToWebKitAnimationEvent, gTypeWebKitAnimationEvent
-  , WebKitCSSFilterValue(WebKitCSSFilterValue), unWebKitCSSFilterValue, castToWebKitCSSFilterValue, gTypeWebKitCSSFilterValue
-  , WebKitCSSMatrix(WebKitCSSMatrix), unWebKitCSSMatrix, castToWebKitCSSMatrix, gTypeWebKitCSSMatrix
-  , WebKitCSSRegionRule(WebKitCSSRegionRule), unWebKitCSSRegionRule, castToWebKitCSSRegionRule, gTypeWebKitCSSRegionRule
-  , WebKitCSSTransformValue(WebKitCSSTransformValue), unWebKitCSSTransformValue, castToWebKitCSSTransformValue, gTypeWebKitCSSTransformValue
-  , WebKitCSSViewportRule(WebKitCSSViewportRule), unWebKitCSSViewportRule, castToWebKitCSSViewportRule, gTypeWebKitCSSViewportRule
-  , WebKitNamedFlow(WebKitNamedFlow), unWebKitNamedFlow, castToWebKitNamedFlow, gTypeWebKitNamedFlow
-  , WebKitNamespace(WebKitNamespace), unWebKitNamespace, castToWebKitNamespace, gTypeWebKitNamespace
-  , WebKitPlaybackTargetAvailabilityEvent(WebKitPlaybackTargetAvailabilityEvent), unWebKitPlaybackTargetAvailabilityEvent, castToWebKitPlaybackTargetAvailabilityEvent, gTypeWebKitPlaybackTargetAvailabilityEvent
-  , WebKitPoint(WebKitPoint), unWebKitPoint, castToWebKitPoint, gTypeWebKitPoint
-  , WebKitTransitionEvent(WebKitTransitionEvent), unWebKitTransitionEvent, castToWebKitTransitionEvent, gTypeWebKitTransitionEvent
-  , WebSocket(WebSocket), unWebSocket, castToWebSocket, gTypeWebSocket
-  , WheelEvent(WheelEvent), unWheelEvent, castToWheelEvent, gTypeWheelEvent
-  , Window(Window), unWindow, castToWindow, gTypeWindow
-  , WindowBase64(WindowBase64), unWindowBase64, castToWindowBase64, gTypeWindowBase64
-  , WindowTimers(WindowTimers), unWindowTimers, castToWindowTimers, gTypeWindowTimers
-  , Worker(Worker), unWorker, castToWorker, gTypeWorker
-  , WorkerGlobalScope(WorkerGlobalScope), unWorkerGlobalScope, IsWorkerGlobalScope, toWorkerGlobalScope, castToWorkerGlobalScope, gTypeWorkerGlobalScope
-  , WorkerLocation(WorkerLocation), unWorkerLocation, castToWorkerLocation, gTypeWorkerLocation
-  , WorkerNavigator(WorkerNavigator), unWorkerNavigator, castToWorkerNavigator, gTypeWorkerNavigator
-  , XMLHttpRequest(XMLHttpRequest), unXMLHttpRequest, castToXMLHttpRequest, gTypeXMLHttpRequest
-  , XMLHttpRequestProgressEvent(XMLHttpRequestProgressEvent), unXMLHttpRequestProgressEvent, castToXMLHttpRequestProgressEvent, gTypeXMLHttpRequestProgressEvent
-  , XMLHttpRequestUpload(XMLHttpRequestUpload), unXMLHttpRequestUpload, castToXMLHttpRequestUpload, gTypeXMLHttpRequestUpload
-  , XMLSerializer(XMLSerializer), unXMLSerializer, castToXMLSerializer, gTypeXMLSerializer
-  , XPathEvaluator(XPathEvaluator), unXPathEvaluator, castToXPathEvaluator, gTypeXPathEvaluator
-  , XPathExpression(XPathExpression), unXPathExpression, castToXPathExpression, gTypeXPathExpression
-  , XPathNSResolver(XPathNSResolver), unXPathNSResolver, castToXPathNSResolver, gTypeXPathNSResolver
-  , XPathResult(XPathResult), unXPathResult, castToXPathResult, gTypeXPathResult
-  , XSLTProcessor(XSLTProcessor), unXSLTProcessor, castToXSLTProcessor, gTypeXSLTProcessor
--- AUTO GENERATION ENDS HERE
-  ) where
-
-import Control.Applicative ((<$>))
-import qualified Data.Text as T (Text)
-import qualified Data.Text.Lazy as LT (Text)
-import Data.JSString (pack, unpack)
-import Data.JSString.Text (textToJSString, textFromJSString, lazyTextToJSString, lazyTextFromJSString)
-import GHCJS.Types (JSVal(..), nullRef, isNull, isUndefined, JSString(..))
-import GHCJS.Marshal (ToJSVal(..), FromJSVal(..))
-import GHCJS.Marshal.Pure (PToJSVal(..), PFromJSVal(..))
-import GHCJS.Nullable (Nullable(..), nullableToMaybe, maybeToNullable)
-import GHCJS.Foreign.Callback.Internal (Callback(..))
-import Control.Monad.IO.Class (MonadIO(..))
-import Data.Int (Int8, Int16, Int32, Int64)
-import Data.Word (Word8, Word16, Word32, Word64)
-
--- | Identifies a JavaScript execution context.
---   When using GHCJS this is just '()' since their is only one context.
---   When using GHC it includes the functions JSaddle needs to communicate
---   with the JavaScript context.
-type JSContextRef = ()
-
--- | This is the same as 'JSContextRef' except when using ghcjs-dom-webkit with GHC (instead of ghcjs-dom-jsaddle)
-type DOMContext = ()
-
--- | The 'JSM' monad keeps track of the JavaScript execution context.
---
---   When using GHCJS it is `IO`.
---
---   Given a 'JSM' function and a 'JSContextRef' you can run the
---   function like this...
---
--- > runJSM jsmFunction javaScriptContext
-type JSM = IO
-
--- | This is the same as 'JSM' except when using ghcjs-dom-webkit with GHC (instead of ghcjs-dom-jsaddle)
-type DOM = IO
-
--- | The 'MonadJSM' is to 'JSM' what 'MonadIO' is to 'IO'.
---   When using GHCJS it is 'MonadIO'.
-type MonadJSM = MonadIO
-
--- | This is the same as 'MonadJSM' except when using ghcjs-dom-webkit with GHC (instead of ghcjs-dom-jsaddle)
-type MonadDOM = MonadIO
-
--- | The 'liftJSM' is to 'JSM' what 'liftIO' is to 'IO'.
---   When using GHCJS it is 'liftIO'.
-liftJSM :: MonadJSM m => JSM a -> m a
-liftJSM = liftIO
-
--- | This is the same as 'liftJSM' except when using ghcjs-dom-webkit with GHC (instead of ghcjs-dom-jsaddle)
-liftDOM :: MonadDOM m => DOM a -> m a
-liftDOM = liftIO
-
--- | Gets the JavaScript context from the monad
-askJSM :: MonadJSM m => m JSContextRef
-askJSM = return ()
-
--- | This is the same as 'askJSM' except when using ghcjs-dom-webkit with GHC (instead of ghcjs-dom-jsaddle)
-askDOM :: MonadDOM m => m DOMContext
-askDOM = return ()
-
--- | Runs a 'JSM' JavaScript function in a given JavaScript context.
-runJSM :: MonadIO m => JSM a -> JSContextRef -> m a
-runJSM f = liftIO . const f
-
--- | This is the same as 'runJSM' except when using ghcjs-dom-webkit with GHC (instead of ghcjs-dom-jsaddle)
-runDOM :: MonadIO m => DOM a -> DOMContext -> m a
-runDOM f = liftIO . const f
-
-maybeJSNullOrUndefined :: JSVal -> Maybe JSVal
-maybeJSNullOrUndefined r | isNull r || isUndefined r = Nothing
-maybeJSNullOrUndefined r = Just r
-
-propagateGError = id
-
-newtype GType = GType JSVal
-
-foreign import javascript unsafe
-  "$1===$2" js_eq :: JSVal -> JSVal -> Bool
-
-strictEqual :: (ToJSVal a, ToJSVal b) => a -> b -> JSM Bool
-strictEqual a b = do
-    aval <- toJSVal a
-    bval <- toJSVal b
-    return $ js_eq aval bval
-
-foreign import javascript unsafe "h$isInstanceOf $1 $2"
-    typeInstanceIsA' :: JSVal -> JSVal -> Bool
-
-typeInstanceIsA o (GType t) = typeInstanceIsA' o t
-
--- The usage of foreignPtrToPtr should be safe as the evaluation will only be
--- forced if the object is used afterwards
---
-castTo :: (IsGObject obj, IsGObject obj') => GType -> String
-                                                -> obj -> IO obj'
-castTo gtype objTypeName obj =
-  case toGObject obj of
-    gobj@(GObject objRef)
-      | typeInstanceIsA objRef gtype
-                  -> return $ unsafeCastGObject gobj
-      | otherwise -> error $ "Cannot cast object to " ++ objTypeName
-
--- | Determine if this is an instance of a particular type
---
-isA :: IsGObject o => o -> GType -> Bool
-isA obj = typeInstanceIsA (unGObject $ toGObject obj)
-
-newtype GObject = GObject { unGObject :: JSVal }
-
-class (ToJSVal o, FromJSVal o) => IsGObject o where
-  -- | Safe upcast.
-  toGObject         :: o -> GObject
-  -- | Unchecked downcast.
-  unsafeCastGObject :: GObject -> o
-
-instance PToJSVal GObject where
-  pToJSVal = unGObject
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal GObject where
-  pFromJSVal = GObject
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal GObject where
-  toJSVal = return . unGObject
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal GObject where
-  fromJSVal = return . fmap GObject . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
---instance IsGObject o => PToJSVal o where
---  pToJSVal = unGObject . toGObject
---  {-# INLINE pToJSVal #-}
---
---instance IsGObject o => PFromJSVal o where
---  pFromJSVal = unsafeCastGObject . GObject . castRef
---  {-# INLINE pFromJSVal #-}
---
---instance IsGObject o => ToJSVal o where
---  toJSVal = return . unGObject . toGObject
---  {-# INLINE toJSVal #-}
---
---instance IsGObject o => FromJSVal o where
---  fromJSVal = return . fmap (unsafeCastGObject . GObject . castRef) . maybeJSNullOrUndefined
---  {-# INLINE fromJSVal #-}
-
-instance IsGObject GObject where
-  toGObject = id
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = id
-  {-# INLINE unsafeCastGObject #-}
-
-castToGObject :: IsGObject obj => obj -> IO obj
-castToGObject = return
-
-foreign import javascript unsafe "object" gTypeGObject :: GType
-
-foreign import javascript unsafe "$1[\"toString\"]()" js_objectToString :: GObject -> IO JSString
-
-objectToString :: (MonadIO m, IsGObject self, FromJSString result) => self -> m result
-objectToString self = liftIO (fromJSString <$> (js_objectToString (toGObject self)))
-
--- | Fastest string type to use when you just
---   want to take a string from the DOM then
---   give it back as is.
-type DOMString = JSString
-
-class (PToJSVal a, ToJSVal a) => ToJSString a
-class (PFromJSVal a, FromJSVal a) => FromJSString a
-
-toJSString :: ToJSString a => a -> JSString
-toJSString = pFromJSVal . pToJSVal
-{-# INLINE toJSString #-}
-
-fromJSString :: FromJSString a => JSString -> a
-fromJSString = pFromJSVal . pToJSVal
-{-# INLINE fromJSString #-}
-
-toMaybeJSString :: ToJSString a => Maybe a -> Nullable JSString
-toMaybeJSString = Nullable . pToJSVal
-{-# INLINE toMaybeJSString #-}
-
-fromMaybeJSString :: FromJSString a => Nullable JSString -> Maybe a
-fromMaybeJSString (Nullable r) = pFromJSVal r
-{-# INLINE fromMaybeJSString #-}
-
-instance ToJSString   [Char]
-instance FromJSString [Char]
-instance ToJSString   T.Text
-instance FromJSString T.Text
-instance ToJSString   JSString
-instance FromJSString JSString
-
-type ToDOMString s = ToJSString s
-type FromDOMString s = FromJSString s
-type IsDOMString s = (ToDOMString s, FromDOMString s)
-
--- Callbacks
-newtype AudioBufferCallback = AudioBufferCallback (Callback (JSVal -> IO ()))
-instance PToJSVal AudioBufferCallback where pToJSVal (AudioBufferCallback (Callback r)) = r
-newtype DatabaseCallback = DatabaseCallback (Callback (JSVal -> IO ()))
-instance PToJSVal DatabaseCallback where pToJSVal (DatabaseCallback (Callback r)) = r
-newtype MediaQueryListListener = MediaQueryListListener (Callback (JSVal -> IO ()))
-instance PToJSVal MediaQueryListListener where pToJSVal (MediaQueryListListener (Callback r)) = r
-newtype MediaStreamTrackSourcesCallback = MediaStreamTrackSourcesCallback (Callback (JSVal -> IO ()))
-instance PToJSVal MediaStreamTrackSourcesCallback where pToJSVal (MediaStreamTrackSourcesCallback (Callback r)) = r
-newtype NavigatorUserMediaErrorCallback = NavigatorUserMediaErrorCallback (Callback (JSVal -> IO ()))
-instance PToJSVal NavigatorUserMediaErrorCallback where pToJSVal (NavigatorUserMediaErrorCallback (Callback r)) = r
-newtype NavigatorUserMediaSuccessCallback = NavigatorUserMediaSuccessCallback (Callback (JSVal -> IO ()))
-instance PToJSVal NavigatorUserMediaSuccessCallback where pToJSVal (NavigatorUserMediaSuccessCallback (Callback r)) = r
-newtype NotificationPermissionCallback permissions = NotificationPermissionCallback (Callback (JSVal -> IO ()))
-instance PToJSVal (NotificationPermissionCallback permissions) where pToJSVal (NotificationPermissionCallback (Callback r)) = r
-newtype PositionCallback = PositionCallback (Callback (JSVal -> IO ()))
-instance PToJSVal PositionCallback where pToJSVal (PositionCallback (Callback r)) = r
-newtype PositionErrorCallback = PositionErrorCallback (Callback (JSVal -> IO ()))
-instance PToJSVal PositionErrorCallback where pToJSVal (PositionErrorCallback (Callback r)) = r
-newtype RequestAnimationFrameCallback = RequestAnimationFrameCallback (Callback (JSVal -> IO ()))
-instance PToJSVal RequestAnimationFrameCallback where pToJSVal (RequestAnimationFrameCallback (Callback r)) = r
-newtype RTCPeerConnectionErrorCallback = RTCPeerConnectionErrorCallback (Callback (JSVal -> IO ()))
-instance PToJSVal RTCPeerConnectionErrorCallback where pToJSVal (RTCPeerConnectionErrorCallback (Callback r)) = r
-newtype RTCSessionDescriptionCallback = RTCSessionDescriptionCallback (Callback (JSVal -> IO ()))
-instance PToJSVal RTCSessionDescriptionCallback where pToJSVal (RTCSessionDescriptionCallback (Callback r)) = r
-newtype RTCStatsCallback = RTCStatsCallback (Callback (JSVal -> IO ()))
-instance PToJSVal RTCStatsCallback where pToJSVal (RTCStatsCallback (Callback r)) = r
-newtype SQLStatementCallback = SQLStatementCallback (Callback (JSVal -> JSVal -> IO ()))
-instance PToJSVal SQLStatementCallback where pToJSVal (SQLStatementCallback (Callback r)) = r
-newtype SQLStatementErrorCallback = SQLStatementErrorCallback (Callback (JSVal -> JSVal -> IO ()))
-instance PToJSVal SQLStatementErrorCallback where pToJSVal (SQLStatementErrorCallback (Callback r)) = r
-newtype SQLTransactionCallback = SQLTransactionCallback (Callback (JSVal -> IO ()))
-instance PToJSVal SQLTransactionCallback where pToJSVal (SQLTransactionCallback (Callback r)) = r
-newtype SQLTransactionErrorCallback = SQLTransactionErrorCallback (Callback (JSVal -> IO ()))
-instance PToJSVal SQLTransactionErrorCallback where pToJSVal (SQLTransactionErrorCallback (Callback r)) = r
-newtype StorageErrorCallback = StorageErrorCallback (Callback (JSVal -> IO ()))
-instance PToJSVal StorageErrorCallback where pToJSVal (StorageErrorCallback (Callback r)) = r
-newtype StorageQuotaCallback = StorageQuotaCallback (Callback (JSVal -> IO ()))
-instance PToJSVal StorageQuotaCallback where pToJSVal (StorageQuotaCallback (Callback r)) = r
-newtype StorageUsageCallback = StorageUsageCallback (Callback (JSVal -> JSVal -> IO ()))
-instance PToJSVal StorageUsageCallback where pToJSVal (StorageUsageCallback (Callback r)) = r
-newtype StringCallback s = StringCallback (Callback (JSVal -> IO ()))
-instance PToJSVal (StringCallback s) where pToJSVal (StringCallback (Callback r)) = r
-newtype VoidCallback = VoidCallback (Callback (IO ()))
-instance PToJSVal VoidCallback where pToJSVal (VoidCallback (Callback r)) = r
-
--- Custom types
-newtype SerializedScriptValue = SerializedScriptValue { unSerializedScriptValue :: JSVal }
-
-instance Eq SerializedScriptValue where
-  (SerializedScriptValue a) == (SerializedScriptValue b) = js_eq a b
-
-instance PToJSVal SerializedScriptValue where
-  pToJSVal = unSerializedScriptValue
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SerializedScriptValue where
-  pFromJSVal = SerializedScriptValue
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SerializedScriptValue where
-  toJSVal = return . unSerializedScriptValue
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SerializedScriptValue where
-  fromJSVal = return . fmap SerializedScriptValue . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-class IsGObject o => IsSerializedScriptValue o
-toSerializedScriptValue :: IsSerializedScriptValue o => o -> SerializedScriptValue
-toSerializedScriptValue = unsafeCastGObject . toGObject
-
-instance IsSerializedScriptValue SerializedScriptValue
-instance IsGObject SerializedScriptValue where
-  toGObject = GObject . unSerializedScriptValue
-  unsafeCastGObject = SerializedScriptValue . unGObject
--- TODO add more IsSerializedScriptValue instances
-
-newtype PositionOptions = PositionOptions { unPositionOptions :: JSVal }
-
-instance Eq PositionOptions where
-  (PositionOptions a) == (PositionOptions b) = js_eq a b
-
-instance PToJSVal PositionOptions where
-  pToJSVal = unPositionOptions
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal PositionOptions where
-  pFromJSVal = PositionOptions
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal PositionOptions where
-  toJSVal = return . unPositionOptions
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal PositionOptions where
-  fromJSVal = return . fmap PositionOptions . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-class IsGObject o => IsPositionOptions o
-toPositionOptions :: IsPositionOptions o => o -> PositionOptions
-toPositionOptions = unsafeCastGObject . toGObject
-
-instance IsPositionOptions PositionOptions
-instance IsGObject PositionOptions where
-  toGObject = GObject . unPositionOptions
-  unsafeCastGObject = PositionOptions . unGObject
--- TODO add more IsPositionOptions instances
-
-newtype Dictionary = Dictionary { unDictionary :: JSVal }
-
-instance Eq Dictionary where
-  (Dictionary a) == (Dictionary b) = js_eq a b
-
-instance PToJSVal Dictionary where
-  pToJSVal = unDictionary
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal Dictionary where
-  pFromJSVal = Dictionary
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal Dictionary where
-  toJSVal = return . unDictionary
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal Dictionary where
-  fromJSVal = return . fmap Dictionary . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-class IsGObject o => IsDictionary o
-toDictionary :: IsDictionary o => o -> Dictionary
-toDictionary = unsafeCastGObject . toGObject
-
-instance IsDictionary Dictionary
-instance IsGObject Dictionary where
-  toGObject = GObject . unDictionary
-  unsafeCastGObject = Dictionary . unGObject
--- TODO add more IsDictionary instances
-
-newtype BlobPropertyBag = BlobPropertyBag { unBlobPropertyBag :: JSVal }
-
-instance Eq BlobPropertyBag where
-  (BlobPropertyBag a) == (BlobPropertyBag b) = js_eq a b
-
-instance PToJSVal BlobPropertyBag where
-  pToJSVal = unBlobPropertyBag
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal BlobPropertyBag where
-  pFromJSVal = BlobPropertyBag
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal BlobPropertyBag where
-  toJSVal = return . unBlobPropertyBag
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal BlobPropertyBag where
-  fromJSVal = return . fmap BlobPropertyBag . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-class IsGObject o => IsBlobPropertyBag o
-toBlobPropertyBag :: IsBlobPropertyBag o => o -> BlobPropertyBag
-toBlobPropertyBag = unsafeCastGObject . toGObject
-
-instance IsBlobPropertyBag BlobPropertyBag
-instance IsGObject BlobPropertyBag where
-  toGObject = GObject . unBlobPropertyBag
-  unsafeCastGObject = BlobPropertyBag . unGObject
--- TODO add more IsBlobPropertyBag instances
-
-newtype MutationCallback = MutationCallback { unMutationCallback :: JSVal }
-
-instance Eq MutationCallback where
-  (MutationCallback a) == (MutationCallback b) = js_eq a b
-
-instance PToJSVal MutationCallback where
-  pToJSVal = unMutationCallback
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal MutationCallback where
-  pFromJSVal = MutationCallback
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal MutationCallback where
-  toJSVal = return . unMutationCallback
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal MutationCallback where
-  fromJSVal = return . fmap MutationCallback . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-class IsGObject o => IsMutationCallback o
-toMutationCallback :: IsMutationCallback o => o -> MutationCallback
-toMutationCallback = unsafeCastGObject . toGObject
-
-instance IsMutationCallback MutationCallback
-instance IsGObject MutationCallback where
-  toGObject = GObject . unMutationCallback
-  unsafeCastGObject = MutationCallback . unGObject
--- TODO add more IsMutationCallback instances
-
-newtype Promise = Promise { unPromise :: JSVal }
-
-instance Eq Promise where
-  (Promise a) == (Promise b) = js_eq a b
-
-instance PToJSVal Promise where
-  pToJSVal = unPromise
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal Promise where
-  pFromJSVal = Promise
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal Promise where
-  toJSVal = return . unPromise
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal Promise where
-  fromJSVal = return . fmap Promise . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-class IsGObject o => IsPromise o
-toPromise :: IsPromise o => o -> Promise
-toPromise = unsafeCastGObject . toGObject
-
-instance IsPromise Promise
-instance IsGObject Promise where
-  toGObject = GObject . unPromise
-  unsafeCastGObject = Promise . unGObject
--- TODO add more IsPromise instances
-
-castToPromise :: IsGObject obj => obj -> IO Promise
-castToPromise = castTo gTypePromise "Promise"
-
-foreign import javascript unsafe "window[\"Promise\"]" gTypePromise :: GType
-
-newtype ArrayBuffer = ArrayBuffer { unArrayBuffer :: JSVal }
-
-instance Eq ArrayBuffer where
-  (ArrayBuffer a) == (ArrayBuffer b) = js_eq a b
-
-instance PToJSVal ArrayBuffer where
-  pToJSVal = unArrayBuffer
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal ArrayBuffer where
-  pFromJSVal = ArrayBuffer
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal ArrayBuffer where
-  toJSVal = return . unArrayBuffer
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal ArrayBuffer where
-  fromJSVal = return . fmap ArrayBuffer . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-class IsGObject o => IsArrayBuffer o
-toArrayBuffer :: IsArrayBuffer o => o -> ArrayBuffer
-toArrayBuffer = unsafeCastGObject . toGObject
-
-instance IsArrayBuffer ArrayBuffer
-instance IsGObject ArrayBuffer where
-  toGObject = GObject . unArrayBuffer
-  unsafeCastGObject = ArrayBuffer . unGObject
-
-castToArrayBuffer :: IsGObject obj => obj -> IO ArrayBuffer
-castToArrayBuffer = castTo gTypeArrayBuffer "ArrayBuffer"
-
-foreign import javascript unsafe "window[\"ArrayBuffer\"]" gTypeArrayBuffer :: GType
-
-newtype Float32Array = Float32Array { unFloat32Array :: JSVal }
-
-instance Eq Float32Array where
-  (Float32Array a) == (Float32Array b) = js_eq a b
-
-instance PToJSVal Float32Array where
-  pToJSVal = unFloat32Array
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal Float32Array where
-  pFromJSVal = Float32Array
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal Float32Array where
-  toJSVal = return . unFloat32Array
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal Float32Array where
-  fromJSVal = return . fmap Float32Array . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-class IsGObject o => IsFloat32Array o
-toFloat32Array :: IsFloat32Array o => o -> Float32Array
-toFloat32Array = unsafeCastGObject . toGObject
-
-instance IsFloat32Array Float32Array
-instance IsGObject Float32Array where
-  toGObject = GObject . unFloat32Array
-  unsafeCastGObject = Float32Array . unGObject
--- TODO add more IsFloat32Array instances
-
-castToFloat32Array :: IsGObject obj => obj -> IO Float32Array
-castToFloat32Array = castTo gTypeFloat32Array "Float32Array"
-
-foreign import javascript unsafe "window[\"Float32Array\"]" gTypeFloat32Array :: GType
-
-newtype Float64Array = Float64Array { unFloat64Array :: JSVal }
-
-instance Eq Float64Array where
-  (Float64Array a) == (Float64Array b) = js_eq a b
-
-instance PToJSVal Float64Array where
-  pToJSVal = unFloat64Array
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal Float64Array where
-  pFromJSVal = Float64Array
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal Float64Array where
-  toJSVal = return . unFloat64Array
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal Float64Array where
-  fromJSVal = return . fmap Float64Array . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-class IsGObject o => IsFloat64Array o
-toFloat64Array :: IsFloat64Array o => o -> Float64Array
-toFloat64Array = unsafeCastGObject . toGObject
-
-instance IsFloat64Array Float64Array
-instance IsGObject Float64Array where
-  toGObject = GObject . unFloat64Array
-  unsafeCastGObject = Float64Array . unGObject
--- TODO add more IsFloat64Array instances
-
-castToFloat64Array :: IsGObject obj => obj -> IO Float64Array
-castToFloat64Array = castTo gTypeFloat64Array "Float64Array"
-
-foreign import javascript unsafe "window[\"Float64Array\"]" gTypeFloat64Array :: GType
-
-newtype Uint8Array = Uint8Array { unUint8Array :: JSVal }
-
-instance Eq Uint8Array where
-  (Uint8Array a) == (Uint8Array b) = js_eq a b
-
-instance PToJSVal Uint8Array where
-  pToJSVal = unUint8Array
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal Uint8Array where
-  pFromJSVal = Uint8Array
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal Uint8Array where
-  toJSVal = return . unUint8Array
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal Uint8Array where
-  fromJSVal = return . fmap Uint8Array . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-class IsGObject o => IsUint8Array o
-toUint8Array :: IsUint8Array o => o -> Uint8Array
-toUint8Array = unsafeCastGObject . toGObject
-
-instance IsUint8Array Uint8Array
-instance IsGObject Uint8Array where
-  toGObject = GObject . unUint8Array
-  unsafeCastGObject = Uint8Array . unGObject
--- TODO add more IsUint8Array instances
-
-castToUint8Array :: IsGObject obj => obj -> IO Uint8Array
-castToUint8Array = castTo gTypeUint8Array "Uint8Array"
-
-foreign import javascript unsafe "window[\"Uint8Array\"]" gTypeUint8Array :: GType
-
-newtype Uint8ClampedArray = Uint8ClampedArray { unUint8ClampedArray :: JSVal }
-
-instance Eq Uint8ClampedArray where
-  (Uint8ClampedArray a) == (Uint8ClampedArray b) = js_eq a b
-
-instance PToJSVal Uint8ClampedArray where
-  pToJSVal = unUint8ClampedArray
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal Uint8ClampedArray where
-  pFromJSVal = Uint8ClampedArray
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal Uint8ClampedArray where
-  toJSVal = return . unUint8ClampedArray
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal Uint8ClampedArray where
-  fromJSVal = return . fmap Uint8ClampedArray . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-class IsGObject o => IsUint8ClampedArray o
-toUint8ClampedArray :: IsUint8ClampedArray o => o -> Uint8ClampedArray
-toUint8ClampedArray = unsafeCastGObject . toGObject
-
-instance IsUint8ClampedArray Uint8ClampedArray
-instance IsGObject Uint8ClampedArray where
-  toGObject = GObject . unUint8ClampedArray
-  unsafeCastGObject = Uint8ClampedArray . unGObject
--- TODO add more IsUint8ClampedArray instances
-
-castToUint8ClampedArray :: IsGObject obj => obj -> IO Uint8ClampedArray
-castToUint8ClampedArray = castTo gTypeUint8ClampedArray "Uint8ClampedArray"
-
-foreign import javascript unsafe "window[\"Uint8ClampedArray\"]" gTypeUint8ClampedArray :: GType
-
-newtype Uint16Array = Uint16Array { unUint16Array :: JSVal }
-
-instance Eq Uint16Array where
-  (Uint16Array a) == (Uint16Array b) = js_eq a b
-
-instance PToJSVal Uint16Array where
-  pToJSVal = unUint16Array
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal Uint16Array where
-  pFromJSVal = Uint16Array
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal Uint16Array where
-  toJSVal = return . unUint16Array
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal Uint16Array where
-  fromJSVal = return . fmap Uint16Array . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-class IsGObject o => IsUint16Array o
-toUint16Array :: IsUint16Array o => o -> Uint16Array
-toUint16Array = unsafeCastGObject . toGObject
-
-instance IsUint16Array Uint16Array
-instance IsGObject Uint16Array where
-  toGObject = GObject . unUint16Array
-  unsafeCastGObject = Uint16Array . unGObject
--- TODO add more IsUint16Array instances
-
-castToUint16Array :: IsGObject obj => obj -> IO Uint16Array
-castToUint16Array = castTo gTypeUint16Array "Uint16Array"
-
-foreign import javascript unsafe "window[\"Uint16Array\"]" gTypeUint16Array :: GType
-
-newtype Uint32Array = Uint32Array { unUint32Array :: JSVal }
-
-instance Eq Uint32Array where
-  (Uint32Array a) == (Uint32Array b) = js_eq a b
-
-instance PToJSVal Uint32Array where
-  pToJSVal = unUint32Array
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal Uint32Array where
-  pFromJSVal = Uint32Array
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal Uint32Array where
-  toJSVal = return . unUint32Array
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal Uint32Array where
-  fromJSVal = return . fmap Uint32Array . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-class IsGObject o => IsUint32Array o
-toUint32Array :: IsUint32Array o => o -> Uint32Array
-toUint32Array = unsafeCastGObject . toGObject
-
-instance IsUint32Array Uint32Array
-instance IsGObject Uint32Array where
-  toGObject = GObject . unUint32Array
-  unsafeCastGObject = Uint32Array . unGObject
--- TODO add more IsUint32Array instances
-
-castToUint32Array :: IsGObject obj => obj -> IO Uint32Array
-castToUint32Array = castTo gTypeUint32Array "Uint32Array"
-
-foreign import javascript unsafe "window[\"Uint32Array\"]" gTypeUint32Array :: GType
-
-newtype Int8Array = Int8Array { unInt8Array :: JSVal }
-
-instance Eq Int8Array where
-  (Int8Array a) == (Int8Array b) = js_eq a b
-
-instance PToJSVal Int8Array where
-  pToJSVal = unInt8Array
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal Int8Array where
-  pFromJSVal = Int8Array
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal Int8Array where
-  toJSVal = return . unInt8Array
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal Int8Array where
-  fromJSVal = return . fmap Int8Array . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-class IsGObject o => IsInt8Array o
-toInt8Array :: IsInt8Array o => o -> Int8Array
-toInt8Array = unsafeCastGObject . toGObject
-
-instance IsInt8Array Int8Array
-instance IsGObject Int8Array where
-  toGObject = GObject . unInt8Array
-  unsafeCastGObject = Int8Array . unGObject
--- TODO add more IsInt8Array instances
-
-castToInt8Array :: IsGObject obj => obj -> IO Int8Array
-castToInt8Array = castTo gTypeInt8Array "Int8Array"
-
-foreign import javascript unsafe "window[\"Int8Array\"]" gTypeInt8Array :: GType
-
-newtype Int16Array = Int16Array { unInt16Array :: JSVal }
-
-instance Eq Int16Array where
-  (Int16Array a) == (Int16Array b) = js_eq a b
-
-instance PToJSVal Int16Array where
-  pToJSVal = unInt16Array
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal Int16Array where
-  pFromJSVal = Int16Array
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal Int16Array where
-  toJSVal = return . unInt16Array
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal Int16Array where
-  fromJSVal = return . fmap Int16Array . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-class IsGObject o => IsInt16Array o
-toInt16Array :: IsInt16Array o => o -> Int16Array
-toInt16Array = unsafeCastGObject . toGObject
-
-instance IsInt16Array Int16Array
-instance IsGObject Int16Array where
-  toGObject = GObject . unInt16Array
-  unsafeCastGObject = Int16Array . unGObject
--- TODO add more IsInt16Array instances
-
-castToInt16Array :: IsGObject obj => obj -> IO Int16Array
-castToInt16Array = castTo gTypeInt16Array "Int16Array"
-
-foreign import javascript unsafe "window[\"Int16Array\"]" gTypeInt16Array :: GType
-
-newtype Int32Array = Int32Array { unInt32Array :: JSVal }
-
-instance Eq Int32Array where
-  (Int32Array a) == (Int32Array b) = js_eq a b
-
-instance PToJSVal Int32Array where
-  pToJSVal = unInt32Array
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal Int32Array where
-  pFromJSVal = Int32Array
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal Int32Array where
-  toJSVal = return . unInt32Array
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal Int32Array where
-  fromJSVal = return . fmap Int32Array . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-class IsGObject o => IsInt32Array o
-toInt32Array :: IsInt32Array o => o -> Int32Array
-toInt32Array = unsafeCastGObject . toGObject
-
-instance IsInt32Array Int32Array
-instance IsGObject Int32Array where
-  toGObject = GObject . unInt32Array
-  unsafeCastGObject = Int32Array . unGObject
--- TODO add more IsInt32Array instances
-
-castToInt32Array :: IsGObject obj => obj -> IO Int32Array
-castToInt32Array = castTo gTypeInt32Array "Int32Array"
-
-foreign import javascript unsafe "window[\"Int32Array\"]" gTypeInt32Array :: GType
-
-newtype ObjectArray = ObjectArray { unObjectArray :: JSVal }
-
-instance Eq ObjectArray where
-  (ObjectArray a) == (ObjectArray b) = js_eq a b
-
-instance PToJSVal ObjectArray where
-  pToJSVal = unObjectArray
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal ObjectArray where
-  pFromJSVal = ObjectArray
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal ObjectArray where
-  toJSVal = return . unObjectArray
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal ObjectArray where
-  fromJSVal = return . fmap ObjectArray . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-class IsGObject o => IsObjectArray o
-toObjectArray :: IsObjectArray o => o -> ObjectArray
-toObjectArray = unsafeCastGObject . toGObject
-
-instance IsObjectArray ObjectArray
-instance IsGObject ObjectArray where
-  toGObject = GObject . unObjectArray
-  unsafeCastGObject = ObjectArray . unGObject
--- TODO add more IsObjectArray instances
-
-newtype ArrayBufferView = ArrayBufferView { unArrayBufferView :: JSVal }
-
-instance Eq ArrayBufferView where
-  (ArrayBufferView a) == (ArrayBufferView b) = js_eq a b
-
-instance PToJSVal ArrayBufferView where
-  pToJSVal = unArrayBufferView
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal ArrayBufferView where
-  pFromJSVal = ArrayBufferView
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal ArrayBufferView where
-  toJSVal = return . unArrayBufferView
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal ArrayBufferView where
-  fromJSVal = return . fmap ArrayBufferView . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-class IsGObject o => IsArrayBufferView o
-toArrayBufferView :: IsArrayBufferView o => o -> ArrayBufferView
-toArrayBufferView = unsafeCastGObject . toGObject
-
-instance IsArrayBufferView ArrayBufferView
-instance IsGObject ArrayBufferView where
-  toGObject = GObject . unArrayBufferView
-  unsafeCastGObject = ArrayBufferView . unGObject
--- TODO add more IsArrayBufferView instances
-
-newtype Array = Array { unArray :: JSVal }
-
-instance Eq Array where
-  (Array a) == (Array b) = js_eq a b
-
-instance PToJSVal Array where
-  pToJSVal = unArray
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal Array where
-  pFromJSVal = Array
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal Array where
-  toJSVal = return . unArray
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal Array where
-  fromJSVal = return . fmap Array . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-class IsGObject o => IsArray o
-toArray :: IsArray o => o -> Array
-toArray = unsafeCastGObject . toGObject
-
-instance IsArray Array
-instance IsGObject Array where
-  toGObject = GObject . unArray
-  unsafeCastGObject = Array . unGObject
--- TODO add more IsArray instances
-
-castToArray :: IsGObject obj => obj -> IO Array
-castToArray = castTo gTypeArray "Array"
-
-foreign import javascript unsafe "window[\"Array\"]" gTypeArray :: GType
-
-newtype Date = Date { unDate :: JSVal }
-
-instance Eq Date where
-  (Date a) == (Date b) = js_eq a b
-
-instance PToJSVal Date where
-  pToJSVal = unDate
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal Date where
-  pFromJSVal = Date
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal Date where
-  toJSVal = return . unDate
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal Date where
-  fromJSVal = return . fmap Date . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-class IsGObject o => IsDate o
-toDate :: IsDate o => o -> Date
-toDate = unsafeCastGObject . toGObject
-
-instance IsDate Date
-instance IsGObject Date where
-  toGObject = GObject . unDate
-  unsafeCastGObject = Date . unGObject
--- TODO add more IsDate instances
-
-castToDate :: IsGObject obj => obj -> IO Date
-castToDate = castTo gTypeDate "Date"
-
-foreign import javascript unsafe "window[\"Date\"]" gTypeDate :: GType
-
-newtype Acceleration = Acceleration { unAcceleration :: JSVal }
-
-instance Eq Acceleration where
-  (Acceleration a) == (Acceleration b) = js_eq a b
-
-instance PToJSVal Acceleration where
-  pToJSVal = unAcceleration
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal Acceleration where
-  pFromJSVal = Acceleration
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal Acceleration where
-  toJSVal = return . unAcceleration
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal Acceleration where
-  fromJSVal = return . fmap Acceleration . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-class IsGObject o => IsAcceleration o
-toAcceleration :: IsAcceleration o => o -> Acceleration
-toAcceleration = unsafeCastGObject . toGObject
-
-instance IsAcceleration Acceleration
-instance IsGObject Acceleration where
-  toGObject = GObject . unAcceleration
-  unsafeCastGObject = Acceleration . unGObject
--- TODO add more IsAcceleration instances
-
-newtype RotationRate = RotationRate { unRotationRate :: JSVal }
-
-instance Eq RotationRate where
-  (RotationRate a) == (RotationRate b) = js_eq a b
-
-instance PToJSVal RotationRate where
-  pToJSVal = unRotationRate
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal RotationRate where
-  pFromJSVal = RotationRate
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal RotationRate where
-  toJSVal = return . unRotationRate
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal RotationRate where
-  fromJSVal = return . fmap RotationRate . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-class IsGObject o => IsRotationRate o
-toRotationRate :: IsRotationRate o => o -> RotationRate
-toRotationRate = unsafeCastGObject . toGObject
-
-instance IsRotationRate RotationRate
-instance IsGObject RotationRate where
-  toGObject = GObject . unRotationRate
-  unsafeCastGObject = RotationRate . unGObject
--- TODO add more IsRotationRate instances
-
-newtype Algorithm = Algorithm { unAlgorithm :: JSVal }
-
-instance Eq Algorithm where
-  (Algorithm a) == (Algorithm b) = js_eq a b
-
-instance PToJSVal Algorithm where
-  pToJSVal = unAlgorithm
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal Algorithm where
-  pFromJSVal = Algorithm
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal Algorithm where
-  toJSVal = return . unAlgorithm
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal Algorithm where
-  fromJSVal = return . fmap Algorithm . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-class IsGObject o => IsAlgorithm o
-toAlgorithm :: IsAlgorithm o => o -> Algorithm
-toAlgorithm = unsafeCastGObject . toGObject
-
-instance IsAlgorithm Algorithm
-instance IsGObject Algorithm where
-  toGObject = GObject . unAlgorithm
-  unsafeCastGObject = Algorithm . unGObject
--- TODO add more IsAlgorithm instances
-
-newtype CryptoOperationData = CryptoOperationData { unCryptoOperationData :: JSVal }
-
-instance Eq CryptoOperationData where
-  (CryptoOperationData a) == (CryptoOperationData b) = js_eq a b
-
-instance PToJSVal CryptoOperationData where
-  pToJSVal = unCryptoOperationData
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal CryptoOperationData where
-  pFromJSVal = CryptoOperationData
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal CryptoOperationData where
-  toJSVal = return . unCryptoOperationData
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal CryptoOperationData where
-  fromJSVal = return . fmap CryptoOperationData . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-class IsGObject o => IsCryptoOperationData o
-toCryptoOperationData :: IsCryptoOperationData o => o -> CryptoOperationData
-toCryptoOperationData = unsafeCastGObject . toGObject
-
-instance IsCryptoOperationData CryptoOperationData
-instance IsGObject CryptoOperationData where
-  toGObject = GObject . unCryptoOperationData
-  unsafeCastGObject = CryptoOperationData . unGObject
-instance IsCryptoOperationData ArrayBuffer
-instance IsCryptoOperationData ArrayBufferView
-
-newtype CanvasStyle = CanvasStyle { unCanvasStyle :: JSVal }
-
-instance Eq CanvasStyle where
-  (CanvasStyle a) == (CanvasStyle b) = js_eq a b
-
-instance PToJSVal CanvasStyle where
-  pToJSVal = unCanvasStyle
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal CanvasStyle where
-  pFromJSVal = CanvasStyle
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal CanvasStyle where
-  toJSVal = return . unCanvasStyle
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal CanvasStyle where
-  fromJSVal = return . fmap CanvasStyle . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-class IsGObject o => IsCanvasStyle o
-toCanvasStyle :: IsCanvasStyle o => o -> CanvasStyle
-toCanvasStyle = unsafeCastGObject . toGObject
-
-instance IsCanvasStyle CanvasStyle
-instance IsGObject CanvasStyle where
-  toGObject = GObject . unCanvasStyle
-  unsafeCastGObject = CanvasStyle . unGObject
-instance IsCanvasStyle CanvasGradient
-instance IsCanvasStyle CanvasPattern
-
-newtype DOMException = DOMException { unDOMException :: JSVal }
-
-instance Eq DOMException where
-  (DOMException a) == (DOMException b) = js_eq a b
-
-instance PToJSVal DOMException where
-  pToJSVal = unDOMException
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal DOMException where
-  pFromJSVal = DOMException
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal DOMException where
-  toJSVal = return . unDOMException
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal DOMException where
-  fromJSVal = return . fmap DOMException . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-class IsGObject o => IsDOMException o
-toDOMException :: IsDOMException o => o -> DOMException
-toDOMException = unsafeCastGObject . toGObject
-
-instance IsDOMException DOMException
-instance IsGObject DOMException where
-  toGObject = GObject . unDOMException
-  unsafeCastGObject = DOMException . unGObject
-
-type GLenum = Word32
-type GLboolean = Bool
-type GLbitfield = Word32
-type GLbyte = Int8
-type GLshort = Int16
-type GLint = Int32
-type GLint64 = Int64
-type GLsizei = Int32
-type GLintptr = Int64
-type GLsizeiptr = Int64
-type GLubyte = Word8
-type GLushort = Word16
-type GLuint = Word32
-type GLuint64 = Word64
-type GLfloat = Double
-type GLclampf = Double
-
--- AUTO GENERATION STARTS HERE
--- The remainder of this file is generated from IDL files using domconv-webkit-jsffi
--- | Functions for this inteface are in "GHCJS.DOM.ANGLEInstancedArrays".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/ANGLEInstancedArrays Mozilla ANGLEInstancedArrays documentation>
-newtype ANGLEInstancedArrays = ANGLEInstancedArrays { unANGLEInstancedArrays :: JSVal }
-
-instance Eq (ANGLEInstancedArrays) where
-  (ANGLEInstancedArrays a) == (ANGLEInstancedArrays b) = js_eq a b
-
-instance PToJSVal ANGLEInstancedArrays where
-  pToJSVal = unANGLEInstancedArrays
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal ANGLEInstancedArrays where
-  pFromJSVal = ANGLEInstancedArrays
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal ANGLEInstancedArrays where
-  toJSVal = return . unANGLEInstancedArrays
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal ANGLEInstancedArrays where
-  fromJSVal = return . fmap ANGLEInstancedArrays . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject ANGLEInstancedArrays where
-  toGObject = GObject . unANGLEInstancedArrays
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = ANGLEInstancedArrays . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToANGLEInstancedArrays :: IsGObject obj => obj -> IO ANGLEInstancedArrays
-castToANGLEInstancedArrays = castTo gTypeANGLEInstancedArrays "ANGLEInstancedArrays"
-
-foreign import javascript unsafe "window[\"ANGLEInstancedArrays\"]" gTypeANGLEInstancedArrays :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.AbstractView".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/AbstractView Mozilla AbstractView documentation>
-newtype AbstractView = AbstractView { unAbstractView :: JSVal }
-
-instance Eq (AbstractView) where
-  (AbstractView a) == (AbstractView b) = js_eq a b
-
-instance PToJSVal AbstractView where
-  pToJSVal = unAbstractView
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal AbstractView where
-  pFromJSVal = AbstractView
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal AbstractView where
-  toJSVal = return . unAbstractView
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal AbstractView where
-  fromJSVal = return . fmap AbstractView . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject AbstractView where
-  toGObject = GObject . unAbstractView
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = AbstractView . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToAbstractView :: IsGObject obj => obj -> IO AbstractView
-castToAbstractView = castTo gTypeAbstractView "AbstractView"
-
-foreign import javascript unsafe "window[\"AbstractView\"]" gTypeAbstractView :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.AbstractWorker".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/AbstractWorker Mozilla AbstractWorker documentation>
-newtype AbstractWorker = AbstractWorker { unAbstractWorker :: JSVal }
-
-instance Eq (AbstractWorker) where
-  (AbstractWorker a) == (AbstractWorker b) = js_eq a b
-
-instance PToJSVal AbstractWorker where
-  pToJSVal = unAbstractWorker
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal AbstractWorker where
-  pFromJSVal = AbstractWorker
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal AbstractWorker where
-  toJSVal = return . unAbstractWorker
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal AbstractWorker where
-  fromJSVal = return . fmap AbstractWorker . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject AbstractWorker where
-  toGObject = GObject . unAbstractWorker
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = AbstractWorker . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToAbstractWorker :: IsGObject obj => obj -> IO AbstractWorker
-castToAbstractWorker = castTo gTypeAbstractWorker "AbstractWorker"
-
-foreign import javascript unsafe "window[\"AbstractWorker\"]" gTypeAbstractWorker :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.AllAudioCapabilities".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.MediaStreamCapabilities"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/AllAudioCapabilities Mozilla AllAudioCapabilities documentation>
-newtype AllAudioCapabilities = AllAudioCapabilities { unAllAudioCapabilities :: JSVal }
-
-instance Eq (AllAudioCapabilities) where
-  (AllAudioCapabilities a) == (AllAudioCapabilities b) = js_eq a b
-
-instance PToJSVal AllAudioCapabilities where
-  pToJSVal = unAllAudioCapabilities
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal AllAudioCapabilities where
-  pFromJSVal = AllAudioCapabilities
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal AllAudioCapabilities where
-  toJSVal = return . unAllAudioCapabilities
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal AllAudioCapabilities where
-  fromJSVal = return . fmap AllAudioCapabilities . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsMediaStreamCapabilities AllAudioCapabilities
-instance IsGObject AllAudioCapabilities where
-  toGObject = GObject . unAllAudioCapabilities
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = AllAudioCapabilities . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToAllAudioCapabilities :: IsGObject obj => obj -> IO AllAudioCapabilities
-castToAllAudioCapabilities = castTo gTypeAllAudioCapabilities "AllAudioCapabilities"
-
-foreign import javascript unsafe "window[\"AllAudioCapabilities\"]" gTypeAllAudioCapabilities :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.AllVideoCapabilities".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.MediaStreamCapabilities"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/AllVideoCapabilities Mozilla AllVideoCapabilities documentation>
-newtype AllVideoCapabilities = AllVideoCapabilities { unAllVideoCapabilities :: JSVal }
-
-instance Eq (AllVideoCapabilities) where
-  (AllVideoCapabilities a) == (AllVideoCapabilities b) = js_eq a b
-
-instance PToJSVal AllVideoCapabilities where
-  pToJSVal = unAllVideoCapabilities
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal AllVideoCapabilities where
-  pFromJSVal = AllVideoCapabilities
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal AllVideoCapabilities where
-  toJSVal = return . unAllVideoCapabilities
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal AllVideoCapabilities where
-  fromJSVal = return . fmap AllVideoCapabilities . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsMediaStreamCapabilities AllVideoCapabilities
-instance IsGObject AllVideoCapabilities where
-  toGObject = GObject . unAllVideoCapabilities
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = AllVideoCapabilities . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToAllVideoCapabilities :: IsGObject obj => obj -> IO AllVideoCapabilities
-castToAllVideoCapabilities = castTo gTypeAllVideoCapabilities "AllVideoCapabilities"
-
-foreign import javascript unsafe "window[\"AllVideoCapabilities\"]" gTypeAllVideoCapabilities :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.AnalyserNode".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.AudioNode"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/AnalyserNode Mozilla AnalyserNode documentation>
-newtype AnalyserNode = AnalyserNode { unAnalyserNode :: JSVal }
-
-instance Eq (AnalyserNode) where
-  (AnalyserNode a) == (AnalyserNode b) = js_eq a b
-
-instance PToJSVal AnalyserNode where
-  pToJSVal = unAnalyserNode
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal AnalyserNode where
-  pFromJSVal = AnalyserNode
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal AnalyserNode where
-  toJSVal = return . unAnalyserNode
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal AnalyserNode where
-  fromJSVal = return . fmap AnalyserNode . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsAudioNode AnalyserNode
-instance IsEventTarget AnalyserNode
-instance IsGObject AnalyserNode where
-  toGObject = GObject . unAnalyserNode
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = AnalyserNode . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToAnalyserNode :: IsGObject obj => obj -> IO AnalyserNode
-castToAnalyserNode = castTo gTypeAnalyserNode "AnalyserNode"
-
-foreign import javascript unsafe "window[\"AnalyserNode\"]" gTypeAnalyserNode :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.AnimationEvent".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.Event"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/AnimationEvent Mozilla AnimationEvent documentation>
-newtype AnimationEvent = AnimationEvent { unAnimationEvent :: JSVal }
-
-instance Eq (AnimationEvent) where
-  (AnimationEvent a) == (AnimationEvent b) = js_eq a b
-
-instance PToJSVal AnimationEvent where
-  pToJSVal = unAnimationEvent
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal AnimationEvent where
-  pFromJSVal = AnimationEvent
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal AnimationEvent where
-  toJSVal = return . unAnimationEvent
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal AnimationEvent where
-  fromJSVal = return . fmap AnimationEvent . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsEvent AnimationEvent
-instance IsGObject AnimationEvent where
-  toGObject = GObject . unAnimationEvent
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = AnimationEvent . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToAnimationEvent :: IsGObject obj => obj -> IO AnimationEvent
-castToAnimationEvent = castTo gTypeAnimationEvent "AnimationEvent"
-
-foreign import javascript unsafe "window[\"AnimationEvent\"]" gTypeAnimationEvent :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.ApplicationCache".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/ApplicationCache Mozilla ApplicationCache documentation>
-newtype ApplicationCache = ApplicationCache { unApplicationCache :: JSVal }
-
-instance Eq (ApplicationCache) where
-  (ApplicationCache a) == (ApplicationCache b) = js_eq a b
-
-instance PToJSVal ApplicationCache where
-  pToJSVal = unApplicationCache
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal ApplicationCache where
-  pFromJSVal = ApplicationCache
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal ApplicationCache where
-  toJSVal = return . unApplicationCache
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal ApplicationCache where
-  fromJSVal = return . fmap ApplicationCache . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsEventTarget ApplicationCache
-instance IsGObject ApplicationCache where
-  toGObject = GObject . unApplicationCache
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = ApplicationCache . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToApplicationCache :: IsGObject obj => obj -> IO ApplicationCache
-castToApplicationCache = castTo gTypeApplicationCache "ApplicationCache"
-
-foreign import javascript unsafe "window[\"ApplicationCache\"]" gTypeApplicationCache :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.Attr".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/Attr Mozilla Attr documentation>
-newtype Attr = Attr { unAttr :: JSVal }
-
-instance Eq (Attr) where
-  (Attr a) == (Attr b) = js_eq a b
-
-instance PToJSVal Attr where
-  pToJSVal = unAttr
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal Attr where
-  pFromJSVal = Attr
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal Attr where
-  toJSVal = return . unAttr
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal Attr where
-  fromJSVal = return . fmap Attr . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsNode Attr
-instance IsEventTarget Attr
-instance IsGObject Attr where
-  toGObject = GObject . unAttr
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = Attr . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToAttr :: IsGObject obj => obj -> IO Attr
-castToAttr = castTo gTypeAttr "Attr"
-
-foreign import javascript unsafe "window[\"Attr\"]" gTypeAttr :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.AudioBuffer".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/AudioBuffer Mozilla AudioBuffer documentation>
-newtype AudioBuffer = AudioBuffer { unAudioBuffer :: JSVal }
-
-instance Eq (AudioBuffer) where
-  (AudioBuffer a) == (AudioBuffer b) = js_eq a b
-
-instance PToJSVal AudioBuffer where
-  pToJSVal = unAudioBuffer
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal AudioBuffer where
-  pFromJSVal = AudioBuffer
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal AudioBuffer where
-  toJSVal = return . unAudioBuffer
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal AudioBuffer where
-  fromJSVal = return . fmap AudioBuffer . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject AudioBuffer where
-  toGObject = GObject . unAudioBuffer
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = AudioBuffer . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToAudioBuffer :: IsGObject obj => obj -> IO AudioBuffer
-castToAudioBuffer = castTo gTypeAudioBuffer "AudioBuffer"
-
-foreign import javascript unsafe "window[\"AudioBuffer\"]" gTypeAudioBuffer :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.AudioBufferSourceNode".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.AudioNode"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/AudioBufferSourceNode Mozilla AudioBufferSourceNode documentation>
-newtype AudioBufferSourceNode = AudioBufferSourceNode { unAudioBufferSourceNode :: JSVal }
-
-instance Eq (AudioBufferSourceNode) where
-  (AudioBufferSourceNode a) == (AudioBufferSourceNode b) = js_eq a b
-
-instance PToJSVal AudioBufferSourceNode where
-  pToJSVal = unAudioBufferSourceNode
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal AudioBufferSourceNode where
-  pFromJSVal = AudioBufferSourceNode
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal AudioBufferSourceNode where
-  toJSVal = return . unAudioBufferSourceNode
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal AudioBufferSourceNode where
-  fromJSVal = return . fmap AudioBufferSourceNode . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsAudioNode AudioBufferSourceNode
-instance IsEventTarget AudioBufferSourceNode
-instance IsGObject AudioBufferSourceNode where
-  toGObject = GObject . unAudioBufferSourceNode
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = AudioBufferSourceNode . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToAudioBufferSourceNode :: IsGObject obj => obj -> IO AudioBufferSourceNode
-castToAudioBufferSourceNode = castTo gTypeAudioBufferSourceNode "AudioBufferSourceNode"
-
-foreign import javascript unsafe "window[\"AudioBufferSourceNode\"]" gTypeAudioBufferSourceNode :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.AudioContext".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/AudioContext Mozilla AudioContext documentation>
-newtype AudioContext = AudioContext { unAudioContext :: JSVal }
-
-instance Eq (AudioContext) where
-  (AudioContext a) == (AudioContext b) = js_eq a b
-
-instance PToJSVal AudioContext where
-  pToJSVal = unAudioContext
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal AudioContext where
-  pFromJSVal = AudioContext
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal AudioContext where
-  toJSVal = return . unAudioContext
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal AudioContext where
-  fromJSVal = return . fmap AudioContext . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-class IsEventTarget o => IsAudioContext o
-toAudioContext :: IsAudioContext o => o -> AudioContext
-toAudioContext = unsafeCastGObject . toGObject
-
-instance IsAudioContext AudioContext
-instance IsEventTarget AudioContext
-instance IsGObject AudioContext where
-  toGObject = GObject . unAudioContext
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = AudioContext . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToAudioContext :: IsGObject obj => obj -> IO AudioContext
-castToAudioContext = castTo gTypeAudioContext "AudioContext"
-
-foreign import javascript unsafe "window[\"AudioContext\"]" gTypeAudioContext :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.AudioDestinationNode".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.AudioNode"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/AudioDestinationNode Mozilla AudioDestinationNode documentation>
-newtype AudioDestinationNode = AudioDestinationNode { unAudioDestinationNode :: JSVal }
-
-instance Eq (AudioDestinationNode) where
-  (AudioDestinationNode a) == (AudioDestinationNode b) = js_eq a b
-
-instance PToJSVal AudioDestinationNode where
-  pToJSVal = unAudioDestinationNode
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal AudioDestinationNode where
-  pFromJSVal = AudioDestinationNode
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal AudioDestinationNode where
-  toJSVal = return . unAudioDestinationNode
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal AudioDestinationNode where
-  fromJSVal = return . fmap AudioDestinationNode . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsAudioNode AudioDestinationNode
-instance IsEventTarget AudioDestinationNode
-instance IsGObject AudioDestinationNode where
-  toGObject = GObject . unAudioDestinationNode
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = AudioDestinationNode . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToAudioDestinationNode :: IsGObject obj => obj -> IO AudioDestinationNode
-castToAudioDestinationNode = castTo gTypeAudioDestinationNode "AudioDestinationNode"
-
-foreign import javascript unsafe "window[\"AudioDestinationNode\"]" gTypeAudioDestinationNode :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.AudioListener".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/AudioListener Mozilla AudioListener documentation>
-newtype AudioListener = AudioListener { unAudioListener :: JSVal }
-
-instance Eq (AudioListener) where
-  (AudioListener a) == (AudioListener b) = js_eq a b
-
-instance PToJSVal AudioListener where
-  pToJSVal = unAudioListener
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal AudioListener where
-  pFromJSVal = AudioListener
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal AudioListener where
-  toJSVal = return . unAudioListener
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal AudioListener where
-  fromJSVal = return . fmap AudioListener . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject AudioListener where
-  toGObject = GObject . unAudioListener
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = AudioListener . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToAudioListener :: IsGObject obj => obj -> IO AudioListener
-castToAudioListener = castTo gTypeAudioListener "AudioListener"
-
-foreign import javascript unsafe "window[\"AudioListener\"]" gTypeAudioListener :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.AudioNode".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/AudioNode Mozilla AudioNode documentation>
-newtype AudioNode = AudioNode { unAudioNode :: JSVal }
-
-instance Eq (AudioNode) where
-  (AudioNode a) == (AudioNode b) = js_eq a b
-
-instance PToJSVal AudioNode where
-  pToJSVal = unAudioNode
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal AudioNode where
-  pFromJSVal = AudioNode
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal AudioNode where
-  toJSVal = return . unAudioNode
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal AudioNode where
-  fromJSVal = return . fmap AudioNode . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-class IsEventTarget o => IsAudioNode o
-toAudioNode :: IsAudioNode o => o -> AudioNode
-toAudioNode = unsafeCastGObject . toGObject
-
-instance IsAudioNode AudioNode
-instance IsEventTarget AudioNode
-instance IsGObject AudioNode where
-  toGObject = GObject . unAudioNode
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = AudioNode . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToAudioNode :: IsGObject obj => obj -> IO AudioNode
-castToAudioNode = castTo gTypeAudioNode "AudioNode"
-
-foreign import javascript unsafe "window[\"AudioNode\"]" gTypeAudioNode :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.AudioParam".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/AudioParam Mozilla AudioParam documentation>
-newtype AudioParam = AudioParam { unAudioParam :: JSVal }
-
-instance Eq (AudioParam) where
-  (AudioParam a) == (AudioParam b) = js_eq a b
-
-instance PToJSVal AudioParam where
-  pToJSVal = unAudioParam
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal AudioParam where
-  pFromJSVal = AudioParam
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal AudioParam where
-  toJSVal = return . unAudioParam
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal AudioParam where
-  fromJSVal = return . fmap AudioParam . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject AudioParam where
-  toGObject = GObject . unAudioParam
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = AudioParam . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToAudioParam :: IsGObject obj => obj -> IO AudioParam
-castToAudioParam = castTo gTypeAudioParam "AudioParam"
-
-foreign import javascript unsafe "window[\"AudioParam\"]" gTypeAudioParam :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.AudioProcessingEvent".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.Event"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/AudioProcessingEvent Mozilla AudioProcessingEvent documentation>
-newtype AudioProcessingEvent = AudioProcessingEvent { unAudioProcessingEvent :: JSVal }
-
-instance Eq (AudioProcessingEvent) where
-  (AudioProcessingEvent a) == (AudioProcessingEvent b) = js_eq a b
-
-instance PToJSVal AudioProcessingEvent where
-  pToJSVal = unAudioProcessingEvent
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal AudioProcessingEvent where
-  pFromJSVal = AudioProcessingEvent
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal AudioProcessingEvent where
-  toJSVal = return . unAudioProcessingEvent
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal AudioProcessingEvent where
-  fromJSVal = return . fmap AudioProcessingEvent . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsEvent AudioProcessingEvent
-instance IsGObject AudioProcessingEvent where
-  toGObject = GObject . unAudioProcessingEvent
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = AudioProcessingEvent . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToAudioProcessingEvent :: IsGObject obj => obj -> IO AudioProcessingEvent
-castToAudioProcessingEvent = castTo gTypeAudioProcessingEvent "AudioProcessingEvent"
-
-foreign import javascript unsafe "window[\"AudioProcessingEvent\"]" gTypeAudioProcessingEvent :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.AudioStreamTrack".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.MediaStreamTrack"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/AudioStreamTrack Mozilla AudioStreamTrack documentation>
-newtype AudioStreamTrack = AudioStreamTrack { unAudioStreamTrack :: JSVal }
-
-instance Eq (AudioStreamTrack) where
-  (AudioStreamTrack a) == (AudioStreamTrack b) = js_eq a b
-
-instance PToJSVal AudioStreamTrack where
-  pToJSVal = unAudioStreamTrack
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal AudioStreamTrack where
-  pFromJSVal = AudioStreamTrack
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal AudioStreamTrack where
-  toJSVal = return . unAudioStreamTrack
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal AudioStreamTrack where
-  fromJSVal = return . fmap AudioStreamTrack . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsMediaStreamTrack AudioStreamTrack
-instance IsEventTarget AudioStreamTrack
-instance IsGObject AudioStreamTrack where
-  toGObject = GObject . unAudioStreamTrack
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = AudioStreamTrack . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToAudioStreamTrack :: IsGObject obj => obj -> IO AudioStreamTrack
-castToAudioStreamTrack = castTo gTypeAudioStreamTrack "AudioStreamTrack"
-
-foreign import javascript unsafe "window[\"AudioStreamTrack\"]" gTypeAudioStreamTrack :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.AudioTrack".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/AudioTrack Mozilla AudioTrack documentation>
-newtype AudioTrack = AudioTrack { unAudioTrack :: JSVal }
-
-instance Eq (AudioTrack) where
-  (AudioTrack a) == (AudioTrack b) = js_eq a b
-
-instance PToJSVal AudioTrack where
-  pToJSVal = unAudioTrack
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal AudioTrack where
-  pFromJSVal = AudioTrack
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal AudioTrack where
-  toJSVal = return . unAudioTrack
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal AudioTrack where
-  fromJSVal = return . fmap AudioTrack . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject AudioTrack where
-  toGObject = GObject . unAudioTrack
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = AudioTrack . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToAudioTrack :: IsGObject obj => obj -> IO AudioTrack
-castToAudioTrack = castTo gTypeAudioTrack "AudioTrack"
-
-foreign import javascript unsafe "window[\"AudioTrack\"]" gTypeAudioTrack :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.AudioTrackList".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/AudioTrackList Mozilla AudioTrackList documentation>
-newtype AudioTrackList = AudioTrackList { unAudioTrackList :: JSVal }
-
-instance Eq (AudioTrackList) where
-  (AudioTrackList a) == (AudioTrackList b) = js_eq a b
-
-instance PToJSVal AudioTrackList where
-  pToJSVal = unAudioTrackList
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal AudioTrackList where
-  pFromJSVal = AudioTrackList
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal AudioTrackList where
-  toJSVal = return . unAudioTrackList
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal AudioTrackList where
-  fromJSVal = return . fmap AudioTrackList . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsEventTarget AudioTrackList
-instance IsGObject AudioTrackList where
-  toGObject = GObject . unAudioTrackList
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = AudioTrackList . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToAudioTrackList :: IsGObject obj => obj -> IO AudioTrackList
-castToAudioTrackList = castTo gTypeAudioTrackList "AudioTrackList"
-
-foreign import javascript unsafe "window[\"AudioTrackList\"]" gTypeAudioTrackList :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.AutocompleteErrorEvent".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.Event"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/AutocompleteErrorEvent Mozilla AutocompleteErrorEvent documentation>
-newtype AutocompleteErrorEvent = AutocompleteErrorEvent { unAutocompleteErrorEvent :: JSVal }
-
-instance Eq (AutocompleteErrorEvent) where
-  (AutocompleteErrorEvent a) == (AutocompleteErrorEvent b) = js_eq a b
-
-instance PToJSVal AutocompleteErrorEvent where
-  pToJSVal = unAutocompleteErrorEvent
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal AutocompleteErrorEvent where
-  pFromJSVal = AutocompleteErrorEvent
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal AutocompleteErrorEvent where
-  toJSVal = return . unAutocompleteErrorEvent
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal AutocompleteErrorEvent where
-  fromJSVal = return . fmap AutocompleteErrorEvent . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsEvent AutocompleteErrorEvent
-instance IsGObject AutocompleteErrorEvent where
-  toGObject = GObject . unAutocompleteErrorEvent
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = AutocompleteErrorEvent . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToAutocompleteErrorEvent :: IsGObject obj => obj -> IO AutocompleteErrorEvent
-castToAutocompleteErrorEvent = castTo gTypeAutocompleteErrorEvent "AutocompleteErrorEvent"
-
-foreign import javascript unsafe "window[\"AutocompleteErrorEvent\"]" gTypeAutocompleteErrorEvent :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.BarProp".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/BarProp Mozilla BarProp documentation>
-newtype BarProp = BarProp { unBarProp :: JSVal }
-
-instance Eq (BarProp) where
-  (BarProp a) == (BarProp b) = js_eq a b
-
-instance PToJSVal BarProp where
-  pToJSVal = unBarProp
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal BarProp where
-  pFromJSVal = BarProp
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal BarProp where
-  toJSVal = return . unBarProp
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal BarProp where
-  fromJSVal = return . fmap BarProp . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject BarProp where
-  toGObject = GObject . unBarProp
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = BarProp . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToBarProp :: IsGObject obj => obj -> IO BarProp
-castToBarProp = castTo gTypeBarProp "BarProp"
-
-foreign import javascript unsafe "window[\"BarProp\"]" gTypeBarProp :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.BatteryManager".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/BatteryManager Mozilla BatteryManager documentation>
-newtype BatteryManager = BatteryManager { unBatteryManager :: JSVal }
-
-instance Eq (BatteryManager) where
-  (BatteryManager a) == (BatteryManager b) = js_eq a b
-
-instance PToJSVal BatteryManager where
-  pToJSVal = unBatteryManager
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal BatteryManager where
-  pFromJSVal = BatteryManager
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal BatteryManager where
-  toJSVal = return . unBatteryManager
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal BatteryManager where
-  fromJSVal = return . fmap BatteryManager . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsEventTarget BatteryManager
-instance IsGObject BatteryManager where
-  toGObject = GObject . unBatteryManager
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = BatteryManager . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToBatteryManager :: IsGObject obj => obj -> IO BatteryManager
-castToBatteryManager = castTo gTypeBatteryManager "BatteryManager"
-
-foreign import javascript unsafe "window[\"BatteryManager\"]" gTypeBatteryManager :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.BeforeLoadEvent".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.Event"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/BeforeLoadEvent Mozilla BeforeLoadEvent documentation>
-newtype BeforeLoadEvent = BeforeLoadEvent { unBeforeLoadEvent :: JSVal }
-
-instance Eq (BeforeLoadEvent) where
-  (BeforeLoadEvent a) == (BeforeLoadEvent b) = js_eq a b
-
-instance PToJSVal BeforeLoadEvent where
-  pToJSVal = unBeforeLoadEvent
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal BeforeLoadEvent where
-  pFromJSVal = BeforeLoadEvent
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal BeforeLoadEvent where
-  toJSVal = return . unBeforeLoadEvent
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal BeforeLoadEvent where
-  fromJSVal = return . fmap BeforeLoadEvent . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsEvent BeforeLoadEvent
-instance IsGObject BeforeLoadEvent where
-  toGObject = GObject . unBeforeLoadEvent
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = BeforeLoadEvent . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToBeforeLoadEvent :: IsGObject obj => obj -> IO BeforeLoadEvent
-castToBeforeLoadEvent = castTo gTypeBeforeLoadEvent "BeforeLoadEvent"
-
-foreign import javascript unsafe "window[\"BeforeLoadEvent\"]" gTypeBeforeLoadEvent :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.BeforeUnloadEvent".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.Event"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/BeforeUnloadEvent Mozilla BeforeUnloadEvent documentation>
-newtype BeforeUnloadEvent = BeforeUnloadEvent { unBeforeUnloadEvent :: JSVal }
-
-instance Eq (BeforeUnloadEvent) where
-  (BeforeUnloadEvent a) == (BeforeUnloadEvent b) = js_eq a b
-
-instance PToJSVal BeforeUnloadEvent where
-  pToJSVal = unBeforeUnloadEvent
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal BeforeUnloadEvent where
-  pFromJSVal = BeforeUnloadEvent
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal BeforeUnloadEvent where
-  toJSVal = return . unBeforeUnloadEvent
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal BeforeUnloadEvent where
-  fromJSVal = return . fmap BeforeUnloadEvent . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsEvent BeforeUnloadEvent
-instance IsGObject BeforeUnloadEvent where
-  toGObject = GObject . unBeforeUnloadEvent
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = BeforeUnloadEvent . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToBeforeUnloadEvent :: IsGObject obj => obj -> IO BeforeUnloadEvent
-castToBeforeUnloadEvent = castTo gTypeBeforeUnloadEvent "BeforeUnloadEvent"
-
-foreign import javascript unsafe "window[\"BeforeUnloadEvent\"]" gTypeBeforeUnloadEvent :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.BiquadFilterNode".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.AudioNode"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/BiquadFilterNode Mozilla BiquadFilterNode documentation>
-newtype BiquadFilterNode = BiquadFilterNode { unBiquadFilterNode :: JSVal }
-
-instance Eq (BiquadFilterNode) where
-  (BiquadFilterNode a) == (BiquadFilterNode b) = js_eq a b
-
-instance PToJSVal BiquadFilterNode where
-  pToJSVal = unBiquadFilterNode
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal BiquadFilterNode where
-  pFromJSVal = BiquadFilterNode
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal BiquadFilterNode where
-  toJSVal = return . unBiquadFilterNode
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal BiquadFilterNode where
-  fromJSVal = return . fmap BiquadFilterNode . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsAudioNode BiquadFilterNode
-instance IsEventTarget BiquadFilterNode
-instance IsGObject BiquadFilterNode where
-  toGObject = GObject . unBiquadFilterNode
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = BiquadFilterNode . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToBiquadFilterNode :: IsGObject obj => obj -> IO BiquadFilterNode
-castToBiquadFilterNode = castTo gTypeBiquadFilterNode "BiquadFilterNode"
-
-foreign import javascript unsafe "window[\"BiquadFilterNode\"]" gTypeBiquadFilterNode :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.Blob".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/Blob Mozilla Blob documentation>
-newtype Blob = Blob { unBlob :: JSVal }
-
-instance Eq (Blob) where
-  (Blob a) == (Blob b) = js_eq a b
-
-instance PToJSVal Blob where
-  pToJSVal = unBlob
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal Blob where
-  pFromJSVal = Blob
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal Blob where
-  toJSVal = return . unBlob
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal Blob where
-  fromJSVal = return . fmap Blob . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-class IsGObject o => IsBlob o
-toBlob :: IsBlob o => o -> Blob
-toBlob = unsafeCastGObject . toGObject
-
-instance IsBlob Blob
-instance IsGObject Blob where
-  toGObject = GObject . unBlob
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = Blob . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToBlob :: IsGObject obj => obj -> IO Blob
-castToBlob = castTo gTypeBlob "Blob"
-
-foreign import javascript unsafe "window[\"Blob\"]" gTypeBlob :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.CDATASection".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.Text"
---     * "GHCJS.DOM.CharacterData"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/CDATASection Mozilla CDATASection documentation>
-newtype CDATASection = CDATASection { unCDATASection :: JSVal }
-
-instance Eq (CDATASection) where
-  (CDATASection a) == (CDATASection b) = js_eq a b
-
-instance PToJSVal CDATASection where
-  pToJSVal = unCDATASection
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal CDATASection where
-  pFromJSVal = CDATASection
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal CDATASection where
-  toJSVal = return . unCDATASection
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal CDATASection where
-  fromJSVal = return . fmap CDATASection . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsText CDATASection
-instance IsCharacterData CDATASection
-instance IsNode CDATASection
-instance IsEventTarget CDATASection
-instance IsGObject CDATASection where
-  toGObject = GObject . unCDATASection
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = CDATASection . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToCDATASection :: IsGObject obj => obj -> IO CDATASection
-castToCDATASection = castTo gTypeCDATASection "CDATASection"
-
-foreign import javascript unsafe "window[\"CDATASection\"]" gTypeCDATASection :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.CSS".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/CSS Mozilla CSS documentation>
-newtype CSS = CSS { unCSS :: JSVal }
-
-instance Eq (CSS) where
-  (CSS a) == (CSS b) = js_eq a b
-
-instance PToJSVal CSS where
-  pToJSVal = unCSS
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal CSS where
-  pFromJSVal = CSS
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal CSS where
-  toJSVal = return . unCSS
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal CSS where
-  fromJSVal = return . fmap CSS . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject CSS where
-  toGObject = GObject . unCSS
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = CSS . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToCSS :: IsGObject obj => obj -> IO CSS
-castToCSS = castTo gTypeCSS "CSS"
-
-foreign import javascript unsafe "window[\"CSS\"]" gTypeCSS :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.CSSCharsetRule".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.CSSRule"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/CSSCharsetRule Mozilla CSSCharsetRule documentation>
-newtype CSSCharsetRule = CSSCharsetRule { unCSSCharsetRule :: JSVal }
-
-instance Eq (CSSCharsetRule) where
-  (CSSCharsetRule a) == (CSSCharsetRule b) = js_eq a b
-
-instance PToJSVal CSSCharsetRule where
-  pToJSVal = unCSSCharsetRule
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal CSSCharsetRule where
-  pFromJSVal = CSSCharsetRule
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal CSSCharsetRule where
-  toJSVal = return . unCSSCharsetRule
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal CSSCharsetRule where
-  fromJSVal = return . fmap CSSCharsetRule . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsCSSRule CSSCharsetRule
-instance IsGObject CSSCharsetRule where
-  toGObject = GObject . unCSSCharsetRule
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = CSSCharsetRule . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToCSSCharsetRule :: IsGObject obj => obj -> IO CSSCharsetRule
-castToCSSCharsetRule = castTo gTypeCSSCharsetRule "CSSCharsetRule"
-
-foreign import javascript unsafe "window[\"CSSCharsetRule\"]" gTypeCSSCharsetRule :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.CSSFontFaceLoadEvent".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.Event"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/CSSFontFaceLoadEvent Mozilla CSSFontFaceLoadEvent documentation>
-newtype CSSFontFaceLoadEvent = CSSFontFaceLoadEvent { unCSSFontFaceLoadEvent :: JSVal }
-
-instance Eq (CSSFontFaceLoadEvent) where
-  (CSSFontFaceLoadEvent a) == (CSSFontFaceLoadEvent b) = js_eq a b
-
-instance PToJSVal CSSFontFaceLoadEvent where
-  pToJSVal = unCSSFontFaceLoadEvent
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal CSSFontFaceLoadEvent where
-  pFromJSVal = CSSFontFaceLoadEvent
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal CSSFontFaceLoadEvent where
-  toJSVal = return . unCSSFontFaceLoadEvent
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal CSSFontFaceLoadEvent where
-  fromJSVal = return . fmap CSSFontFaceLoadEvent . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsEvent CSSFontFaceLoadEvent
-instance IsGObject CSSFontFaceLoadEvent where
-  toGObject = GObject . unCSSFontFaceLoadEvent
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = CSSFontFaceLoadEvent . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToCSSFontFaceLoadEvent :: IsGObject obj => obj -> IO CSSFontFaceLoadEvent
-castToCSSFontFaceLoadEvent = castTo gTypeCSSFontFaceLoadEvent "CSSFontFaceLoadEvent"
-
-foreign import javascript unsafe "window[\"CSSFontFaceLoadEvent\"]" gTypeCSSFontFaceLoadEvent :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.CSSFontFaceRule".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.CSSRule"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/CSSFontFaceRule Mozilla CSSFontFaceRule documentation>
-newtype CSSFontFaceRule = CSSFontFaceRule { unCSSFontFaceRule :: JSVal }
-
-instance Eq (CSSFontFaceRule) where
-  (CSSFontFaceRule a) == (CSSFontFaceRule b) = js_eq a b
-
-instance PToJSVal CSSFontFaceRule where
-  pToJSVal = unCSSFontFaceRule
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal CSSFontFaceRule where
-  pFromJSVal = CSSFontFaceRule
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal CSSFontFaceRule where
-  toJSVal = return . unCSSFontFaceRule
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal CSSFontFaceRule where
-  fromJSVal = return . fmap CSSFontFaceRule . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsCSSRule CSSFontFaceRule
-instance IsGObject CSSFontFaceRule where
-  toGObject = GObject . unCSSFontFaceRule
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = CSSFontFaceRule . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToCSSFontFaceRule :: IsGObject obj => obj -> IO CSSFontFaceRule
-castToCSSFontFaceRule = castTo gTypeCSSFontFaceRule "CSSFontFaceRule"
-
-foreign import javascript unsafe "window[\"CSSFontFaceRule\"]" gTypeCSSFontFaceRule :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.CSSImportRule".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.CSSRule"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/CSSImportRule Mozilla CSSImportRule documentation>
-newtype CSSImportRule = CSSImportRule { unCSSImportRule :: JSVal }
-
-instance Eq (CSSImportRule) where
-  (CSSImportRule a) == (CSSImportRule b) = js_eq a b
-
-instance PToJSVal CSSImportRule where
-  pToJSVal = unCSSImportRule
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal CSSImportRule where
-  pFromJSVal = CSSImportRule
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal CSSImportRule where
-  toJSVal = return . unCSSImportRule
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal CSSImportRule where
-  fromJSVal = return . fmap CSSImportRule . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsCSSRule CSSImportRule
-instance IsGObject CSSImportRule where
-  toGObject = GObject . unCSSImportRule
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = CSSImportRule . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToCSSImportRule :: IsGObject obj => obj -> IO CSSImportRule
-castToCSSImportRule = castTo gTypeCSSImportRule "CSSImportRule"
-
-foreign import javascript unsafe "window[\"CSSImportRule\"]" gTypeCSSImportRule :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.CSSKeyframeRule".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.CSSRule"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/CSSKeyframeRule Mozilla CSSKeyframeRule documentation>
-newtype CSSKeyframeRule = CSSKeyframeRule { unCSSKeyframeRule :: JSVal }
-
-instance Eq (CSSKeyframeRule) where
-  (CSSKeyframeRule a) == (CSSKeyframeRule b) = js_eq a b
-
-instance PToJSVal CSSKeyframeRule where
-  pToJSVal = unCSSKeyframeRule
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal CSSKeyframeRule where
-  pFromJSVal = CSSKeyframeRule
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal CSSKeyframeRule where
-  toJSVal = return . unCSSKeyframeRule
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal CSSKeyframeRule where
-  fromJSVal = return . fmap CSSKeyframeRule . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsCSSRule CSSKeyframeRule
-instance IsGObject CSSKeyframeRule where
-  toGObject = GObject . unCSSKeyframeRule
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = CSSKeyframeRule . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToCSSKeyframeRule :: IsGObject obj => obj -> IO CSSKeyframeRule
-castToCSSKeyframeRule = castTo gTypeCSSKeyframeRule "CSSKeyframeRule"
-
-foreign import javascript unsafe "window[\"CSSKeyframeRule\"]" gTypeCSSKeyframeRule :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.CSSKeyframesRule".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.CSSRule"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/CSSKeyframesRule Mozilla CSSKeyframesRule documentation>
-newtype CSSKeyframesRule = CSSKeyframesRule { unCSSKeyframesRule :: JSVal }
-
-instance Eq (CSSKeyframesRule) where
-  (CSSKeyframesRule a) == (CSSKeyframesRule b) = js_eq a b
-
-instance PToJSVal CSSKeyframesRule where
-  pToJSVal = unCSSKeyframesRule
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal CSSKeyframesRule where
-  pFromJSVal = CSSKeyframesRule
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal CSSKeyframesRule where
-  toJSVal = return . unCSSKeyframesRule
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal CSSKeyframesRule where
-  fromJSVal = return . fmap CSSKeyframesRule . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsCSSRule CSSKeyframesRule
-instance IsGObject CSSKeyframesRule where
-  toGObject = GObject . unCSSKeyframesRule
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = CSSKeyframesRule . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToCSSKeyframesRule :: IsGObject obj => obj -> IO CSSKeyframesRule
-castToCSSKeyframesRule = castTo gTypeCSSKeyframesRule "CSSKeyframesRule"
-
-foreign import javascript unsafe "window[\"CSSKeyframesRule\"]" gTypeCSSKeyframesRule :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.CSSMediaRule".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.CSSRule"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/CSSMediaRule Mozilla CSSMediaRule documentation>
-newtype CSSMediaRule = CSSMediaRule { unCSSMediaRule :: JSVal }
-
-instance Eq (CSSMediaRule) where
-  (CSSMediaRule a) == (CSSMediaRule b) = js_eq a b
-
-instance PToJSVal CSSMediaRule where
-  pToJSVal = unCSSMediaRule
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal CSSMediaRule where
-  pFromJSVal = CSSMediaRule
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal CSSMediaRule where
-  toJSVal = return . unCSSMediaRule
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal CSSMediaRule where
-  fromJSVal = return . fmap CSSMediaRule . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsCSSRule CSSMediaRule
-instance IsGObject CSSMediaRule where
-  toGObject = GObject . unCSSMediaRule
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = CSSMediaRule . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToCSSMediaRule :: IsGObject obj => obj -> IO CSSMediaRule
-castToCSSMediaRule = castTo gTypeCSSMediaRule "CSSMediaRule"
-
-foreign import javascript unsafe "window[\"CSSMediaRule\"]" gTypeCSSMediaRule :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.CSSPageRule".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.CSSRule"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/CSSPageRule Mozilla CSSPageRule documentation>
-newtype CSSPageRule = CSSPageRule { unCSSPageRule :: JSVal }
-
-instance Eq (CSSPageRule) where
-  (CSSPageRule a) == (CSSPageRule b) = js_eq a b
-
-instance PToJSVal CSSPageRule where
-  pToJSVal = unCSSPageRule
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal CSSPageRule where
-  pFromJSVal = CSSPageRule
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal CSSPageRule where
-  toJSVal = return . unCSSPageRule
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal CSSPageRule where
-  fromJSVal = return . fmap CSSPageRule . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsCSSRule CSSPageRule
-instance IsGObject CSSPageRule where
-  toGObject = GObject . unCSSPageRule
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = CSSPageRule . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToCSSPageRule :: IsGObject obj => obj -> IO CSSPageRule
-castToCSSPageRule = castTo gTypeCSSPageRule "CSSPageRule"
-
-foreign import javascript unsafe "window[\"CSSPageRule\"]" gTypeCSSPageRule :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.CSSPrimitiveValue".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.CSSValue"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/CSSPrimitiveValue Mozilla CSSPrimitiveValue documentation>
-newtype CSSPrimitiveValue = CSSPrimitiveValue { unCSSPrimitiveValue :: JSVal }
-
-instance Eq (CSSPrimitiveValue) where
-  (CSSPrimitiveValue a) == (CSSPrimitiveValue b) = js_eq a b
-
-instance PToJSVal CSSPrimitiveValue where
-  pToJSVal = unCSSPrimitiveValue
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal CSSPrimitiveValue where
-  pFromJSVal = CSSPrimitiveValue
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal CSSPrimitiveValue where
-  toJSVal = return . unCSSPrimitiveValue
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal CSSPrimitiveValue where
-  fromJSVal = return . fmap CSSPrimitiveValue . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsCSSValue CSSPrimitiveValue
-instance IsGObject CSSPrimitiveValue where
-  toGObject = GObject . unCSSPrimitiveValue
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = CSSPrimitiveValue . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToCSSPrimitiveValue :: IsGObject obj => obj -> IO CSSPrimitiveValue
-castToCSSPrimitiveValue = castTo gTypeCSSPrimitiveValue "CSSPrimitiveValue"
-
-foreign import javascript unsafe "window[\"CSSPrimitiveValue\"]" gTypeCSSPrimitiveValue :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.CSSRule".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/CSSRule Mozilla CSSRule documentation>
-newtype CSSRule = CSSRule { unCSSRule :: JSVal }
-
-instance Eq (CSSRule) where
-  (CSSRule a) == (CSSRule b) = js_eq a b
-
-instance PToJSVal CSSRule where
-  pToJSVal = unCSSRule
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal CSSRule where
-  pFromJSVal = CSSRule
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal CSSRule where
-  toJSVal = return . unCSSRule
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal CSSRule where
-  fromJSVal = return . fmap CSSRule . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-class IsGObject o => IsCSSRule o
-toCSSRule :: IsCSSRule o => o -> CSSRule
-toCSSRule = unsafeCastGObject . toGObject
-
-instance IsCSSRule CSSRule
-instance IsGObject CSSRule where
-  toGObject = GObject . unCSSRule
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = CSSRule . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToCSSRule :: IsGObject obj => obj -> IO CSSRule
-castToCSSRule = castTo gTypeCSSRule "CSSRule"
-
-foreign import javascript unsafe "window[\"CSSRule\"]" gTypeCSSRule :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.CSSRuleList".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/CSSRuleList Mozilla CSSRuleList documentation>
-newtype CSSRuleList = CSSRuleList { unCSSRuleList :: JSVal }
-
-instance Eq (CSSRuleList) where
-  (CSSRuleList a) == (CSSRuleList b) = js_eq a b
-
-instance PToJSVal CSSRuleList where
-  pToJSVal = unCSSRuleList
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal CSSRuleList where
-  pFromJSVal = CSSRuleList
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal CSSRuleList where
-  toJSVal = return . unCSSRuleList
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal CSSRuleList where
-  fromJSVal = return . fmap CSSRuleList . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject CSSRuleList where
-  toGObject = GObject . unCSSRuleList
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = CSSRuleList . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToCSSRuleList :: IsGObject obj => obj -> IO CSSRuleList
-castToCSSRuleList = castTo gTypeCSSRuleList "CSSRuleList"
-
-foreign import javascript unsafe "window[\"CSSRuleList\"]" gTypeCSSRuleList :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.CSSStyleDeclaration".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/CSSStyleDeclaration Mozilla CSSStyleDeclaration documentation>
-newtype CSSStyleDeclaration = CSSStyleDeclaration { unCSSStyleDeclaration :: JSVal }
-
-instance Eq (CSSStyleDeclaration) where
-  (CSSStyleDeclaration a) == (CSSStyleDeclaration b) = js_eq a b
-
-instance PToJSVal CSSStyleDeclaration where
-  pToJSVal = unCSSStyleDeclaration
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal CSSStyleDeclaration where
-  pFromJSVal = CSSStyleDeclaration
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal CSSStyleDeclaration where
-  toJSVal = return . unCSSStyleDeclaration
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal CSSStyleDeclaration where
-  fromJSVal = return . fmap CSSStyleDeclaration . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject CSSStyleDeclaration where
-  toGObject = GObject . unCSSStyleDeclaration
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = CSSStyleDeclaration . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToCSSStyleDeclaration :: IsGObject obj => obj -> IO CSSStyleDeclaration
-castToCSSStyleDeclaration = castTo gTypeCSSStyleDeclaration "CSSStyleDeclaration"
-
-foreign import javascript unsafe "window[\"CSSStyleDeclaration\"]" gTypeCSSStyleDeclaration :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.CSSStyleRule".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.CSSRule"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/CSSStyleRule Mozilla CSSStyleRule documentation>
-newtype CSSStyleRule = CSSStyleRule { unCSSStyleRule :: JSVal }
-
-instance Eq (CSSStyleRule) where
-  (CSSStyleRule a) == (CSSStyleRule b) = js_eq a b
-
-instance PToJSVal CSSStyleRule where
-  pToJSVal = unCSSStyleRule
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal CSSStyleRule where
-  pFromJSVal = CSSStyleRule
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal CSSStyleRule where
-  toJSVal = return . unCSSStyleRule
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal CSSStyleRule where
-  fromJSVal = return . fmap CSSStyleRule . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsCSSRule CSSStyleRule
-instance IsGObject CSSStyleRule where
-  toGObject = GObject . unCSSStyleRule
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = CSSStyleRule . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToCSSStyleRule :: IsGObject obj => obj -> IO CSSStyleRule
-castToCSSStyleRule = castTo gTypeCSSStyleRule "CSSStyleRule"
-
-foreign import javascript unsafe "window[\"CSSStyleRule\"]" gTypeCSSStyleRule :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.CSSStyleSheet".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.StyleSheet"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/CSSStyleSheet Mozilla CSSStyleSheet documentation>
-newtype CSSStyleSheet = CSSStyleSheet { unCSSStyleSheet :: JSVal }
-
-instance Eq (CSSStyleSheet) where
-  (CSSStyleSheet a) == (CSSStyleSheet b) = js_eq a b
-
-instance PToJSVal CSSStyleSheet where
-  pToJSVal = unCSSStyleSheet
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal CSSStyleSheet where
-  pFromJSVal = CSSStyleSheet
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal CSSStyleSheet where
-  toJSVal = return . unCSSStyleSheet
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal CSSStyleSheet where
-  fromJSVal = return . fmap CSSStyleSheet . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsStyleSheet CSSStyleSheet
-instance IsGObject CSSStyleSheet where
-  toGObject = GObject . unCSSStyleSheet
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = CSSStyleSheet . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToCSSStyleSheet :: IsGObject obj => obj -> IO CSSStyleSheet
-castToCSSStyleSheet = castTo gTypeCSSStyleSheet "CSSStyleSheet"
-
-foreign import javascript unsafe "window[\"CSSStyleSheet\"]" gTypeCSSStyleSheet :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.CSSSupportsRule".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.CSSRule"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/CSSSupportsRule Mozilla CSSSupportsRule documentation>
-newtype CSSSupportsRule = CSSSupportsRule { unCSSSupportsRule :: JSVal }
-
-instance Eq (CSSSupportsRule) where
-  (CSSSupportsRule a) == (CSSSupportsRule b) = js_eq a b
-
-instance PToJSVal CSSSupportsRule where
-  pToJSVal = unCSSSupportsRule
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal CSSSupportsRule where
-  pFromJSVal = CSSSupportsRule
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal CSSSupportsRule where
-  toJSVal = return . unCSSSupportsRule
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal CSSSupportsRule where
-  fromJSVal = return . fmap CSSSupportsRule . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsCSSRule CSSSupportsRule
-instance IsGObject CSSSupportsRule where
-  toGObject = GObject . unCSSSupportsRule
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = CSSSupportsRule . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToCSSSupportsRule :: IsGObject obj => obj -> IO CSSSupportsRule
-castToCSSSupportsRule = castTo gTypeCSSSupportsRule "CSSSupportsRule"
-
-foreign import javascript unsafe "window[\"CSSSupportsRule\"]" gTypeCSSSupportsRule :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.CSSUnknownRule".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.CSSRule"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/CSSUnknownRule Mozilla CSSUnknownRule documentation>
-newtype CSSUnknownRule = CSSUnknownRule { unCSSUnknownRule :: JSVal }
-
-instance Eq (CSSUnknownRule) where
-  (CSSUnknownRule a) == (CSSUnknownRule b) = js_eq a b
-
-instance PToJSVal CSSUnknownRule where
-  pToJSVal = unCSSUnknownRule
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal CSSUnknownRule where
-  pFromJSVal = CSSUnknownRule
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal CSSUnknownRule where
-  toJSVal = return . unCSSUnknownRule
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal CSSUnknownRule where
-  fromJSVal = return . fmap CSSUnknownRule . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsCSSRule CSSUnknownRule
-instance IsGObject CSSUnknownRule where
-  toGObject = GObject . unCSSUnknownRule
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = CSSUnknownRule . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToCSSUnknownRule :: IsGObject obj => obj -> IO CSSUnknownRule
-castToCSSUnknownRule = castTo gTypeCSSUnknownRule "CSSUnknownRule"
-
-foreign import javascript unsafe "window[\"CSSUnknownRule\"]" gTypeCSSUnknownRule :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.CSSValue".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/CSSValue Mozilla CSSValue documentation>
-newtype CSSValue = CSSValue { unCSSValue :: JSVal }
-
-instance Eq (CSSValue) where
-  (CSSValue a) == (CSSValue b) = js_eq a b
-
-instance PToJSVal CSSValue where
-  pToJSVal = unCSSValue
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal CSSValue where
-  pFromJSVal = CSSValue
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal CSSValue where
-  toJSVal = return . unCSSValue
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal CSSValue where
-  fromJSVal = return . fmap CSSValue . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-class IsGObject o => IsCSSValue o
-toCSSValue :: IsCSSValue o => o -> CSSValue
-toCSSValue = unsafeCastGObject . toGObject
-
-instance IsCSSValue CSSValue
-instance IsGObject CSSValue where
-  toGObject = GObject . unCSSValue
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = CSSValue . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToCSSValue :: IsGObject obj => obj -> IO CSSValue
-castToCSSValue = castTo gTypeCSSValue "CSSValue"
-
-foreign import javascript unsafe "window[\"CSSValue\"]" gTypeCSSValue :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.CSSValueList".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.CSSValue"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/CSSValueList Mozilla CSSValueList documentation>
-newtype CSSValueList = CSSValueList { unCSSValueList :: JSVal }
-
-instance Eq (CSSValueList) where
-  (CSSValueList a) == (CSSValueList b) = js_eq a b
-
-instance PToJSVal CSSValueList where
-  pToJSVal = unCSSValueList
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal CSSValueList where
-  pFromJSVal = CSSValueList
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal CSSValueList where
-  toJSVal = return . unCSSValueList
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal CSSValueList where
-  fromJSVal = return . fmap CSSValueList . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-class IsCSSValue o => IsCSSValueList o
-toCSSValueList :: IsCSSValueList o => o -> CSSValueList
-toCSSValueList = unsafeCastGObject . toGObject
-
-instance IsCSSValueList CSSValueList
-instance IsCSSValue CSSValueList
-instance IsGObject CSSValueList where
-  toGObject = GObject . unCSSValueList
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = CSSValueList . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToCSSValueList :: IsGObject obj => obj -> IO CSSValueList
-castToCSSValueList = castTo gTypeCSSValueList "CSSValueList"
-
-foreign import javascript unsafe "window[\"CSSValueList\"]" gTypeCSSValueList :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.CanvasGradient".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/CanvasGradient Mozilla CanvasGradient documentation>
-newtype CanvasGradient = CanvasGradient { unCanvasGradient :: JSVal }
-
-instance Eq (CanvasGradient) where
-  (CanvasGradient a) == (CanvasGradient b) = js_eq a b
-
-instance PToJSVal CanvasGradient where
-  pToJSVal = unCanvasGradient
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal CanvasGradient where
-  pFromJSVal = CanvasGradient
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal CanvasGradient where
-  toJSVal = return . unCanvasGradient
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal CanvasGradient where
-  fromJSVal = return . fmap CanvasGradient . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject CanvasGradient where
-  toGObject = GObject . unCanvasGradient
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = CanvasGradient . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToCanvasGradient :: IsGObject obj => obj -> IO CanvasGradient
-castToCanvasGradient = castTo gTypeCanvasGradient "CanvasGradient"
-
-foreign import javascript unsafe "window[\"CanvasGradient\"]" gTypeCanvasGradient :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.CanvasPattern".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/CanvasPattern Mozilla CanvasPattern documentation>
-newtype CanvasPattern = CanvasPattern { unCanvasPattern :: JSVal }
-
-instance Eq (CanvasPattern) where
-  (CanvasPattern a) == (CanvasPattern b) = js_eq a b
-
-instance PToJSVal CanvasPattern where
-  pToJSVal = unCanvasPattern
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal CanvasPattern where
-  pFromJSVal = CanvasPattern
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal CanvasPattern where
-  toJSVal = return . unCanvasPattern
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal CanvasPattern where
-  fromJSVal = return . fmap CanvasPattern . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject CanvasPattern where
-  toGObject = GObject . unCanvasPattern
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = CanvasPattern . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToCanvasPattern :: IsGObject obj => obj -> IO CanvasPattern
-castToCanvasPattern = castTo gTypeCanvasPattern "CanvasPattern"
-
-foreign import javascript unsafe "window[\"CanvasPattern\"]" gTypeCanvasPattern :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.CanvasProxy".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/CanvasProxy Mozilla CanvasProxy documentation>
-newtype CanvasProxy = CanvasProxy { unCanvasProxy :: JSVal }
-
-instance Eq (CanvasProxy) where
-  (CanvasProxy a) == (CanvasProxy b) = js_eq a b
-
-instance PToJSVal CanvasProxy where
-  pToJSVal = unCanvasProxy
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal CanvasProxy where
-  pFromJSVal = CanvasProxy
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal CanvasProxy where
-  toJSVal = return . unCanvasProxy
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal CanvasProxy where
-  fromJSVal = return . fmap CanvasProxy . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject CanvasProxy where
-  toGObject = GObject . unCanvasProxy
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = CanvasProxy . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToCanvasProxy :: IsGObject obj => obj -> IO CanvasProxy
-castToCanvasProxy = castTo gTypeCanvasProxy "CanvasProxy"
-
-foreign import javascript unsafe "window[\"CanvasProxy\"]" gTypeCanvasProxy :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.CanvasRenderingContext".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/CanvasRenderingContext Mozilla CanvasRenderingContext documentation>
-newtype CanvasRenderingContext = CanvasRenderingContext { unCanvasRenderingContext :: JSVal }
-
-instance Eq (CanvasRenderingContext) where
-  (CanvasRenderingContext a) == (CanvasRenderingContext b) = js_eq a b
-
-instance PToJSVal CanvasRenderingContext where
-  pToJSVal = unCanvasRenderingContext
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal CanvasRenderingContext where
-  pFromJSVal = CanvasRenderingContext
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal CanvasRenderingContext where
-  toJSVal = return . unCanvasRenderingContext
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal CanvasRenderingContext where
-  fromJSVal = return . fmap CanvasRenderingContext . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-class IsGObject o => IsCanvasRenderingContext o
-toCanvasRenderingContext :: IsCanvasRenderingContext o => o -> CanvasRenderingContext
-toCanvasRenderingContext = unsafeCastGObject . toGObject
-
-instance IsCanvasRenderingContext CanvasRenderingContext
-instance IsGObject CanvasRenderingContext where
-  toGObject = GObject . unCanvasRenderingContext
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = CanvasRenderingContext . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToCanvasRenderingContext :: IsGObject obj => obj -> IO CanvasRenderingContext
-castToCanvasRenderingContext = castTo gTypeCanvasRenderingContext "CanvasRenderingContext"
-
-foreign import javascript unsafe "window[\"CanvasRenderingContext\"]" gTypeCanvasRenderingContext :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.CanvasRenderingContext2D".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.CanvasRenderingContext"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/CanvasRenderingContext2D Mozilla CanvasRenderingContext2D documentation>
-newtype CanvasRenderingContext2D = CanvasRenderingContext2D { unCanvasRenderingContext2D :: JSVal }
-
-instance Eq (CanvasRenderingContext2D) where
-  (CanvasRenderingContext2D a) == (CanvasRenderingContext2D b) = js_eq a b
-
-instance PToJSVal CanvasRenderingContext2D where
-  pToJSVal = unCanvasRenderingContext2D
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal CanvasRenderingContext2D where
-  pFromJSVal = CanvasRenderingContext2D
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal CanvasRenderingContext2D where
-  toJSVal = return . unCanvasRenderingContext2D
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal CanvasRenderingContext2D where
-  fromJSVal = return . fmap CanvasRenderingContext2D . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsCanvasRenderingContext CanvasRenderingContext2D
-instance IsGObject CanvasRenderingContext2D where
-  toGObject = GObject . unCanvasRenderingContext2D
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = CanvasRenderingContext2D . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToCanvasRenderingContext2D :: IsGObject obj => obj -> IO CanvasRenderingContext2D
-castToCanvasRenderingContext2D = castTo gTypeCanvasRenderingContext2D "CanvasRenderingContext2D"
-
-foreign import javascript unsafe "window[\"CanvasRenderingContext2D\"]" gTypeCanvasRenderingContext2D :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.CapabilityRange".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/CapabilityRange Mozilla CapabilityRange documentation>
-newtype CapabilityRange = CapabilityRange { unCapabilityRange :: JSVal }
-
-instance Eq (CapabilityRange) where
-  (CapabilityRange a) == (CapabilityRange b) = js_eq a b
-
-instance PToJSVal CapabilityRange where
-  pToJSVal = unCapabilityRange
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal CapabilityRange where
-  pFromJSVal = CapabilityRange
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal CapabilityRange where
-  toJSVal = return . unCapabilityRange
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal CapabilityRange where
-  fromJSVal = return . fmap CapabilityRange . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject CapabilityRange where
-  toGObject = GObject . unCapabilityRange
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = CapabilityRange . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToCapabilityRange :: IsGObject obj => obj -> IO CapabilityRange
-castToCapabilityRange = castTo gTypeCapabilityRange "CapabilityRange"
-
-foreign import javascript unsafe "window[\"CapabilityRange\"]" gTypeCapabilityRange :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.ChannelMergerNode".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.AudioNode"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/ChannelMergerNode Mozilla ChannelMergerNode documentation>
-newtype ChannelMergerNode = ChannelMergerNode { unChannelMergerNode :: JSVal }
-
-instance Eq (ChannelMergerNode) where
-  (ChannelMergerNode a) == (ChannelMergerNode b) = js_eq a b
-
-instance PToJSVal ChannelMergerNode where
-  pToJSVal = unChannelMergerNode
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal ChannelMergerNode where
-  pFromJSVal = ChannelMergerNode
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal ChannelMergerNode where
-  toJSVal = return . unChannelMergerNode
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal ChannelMergerNode where
-  fromJSVal = return . fmap ChannelMergerNode . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsAudioNode ChannelMergerNode
-instance IsEventTarget ChannelMergerNode
-instance IsGObject ChannelMergerNode where
-  toGObject = GObject . unChannelMergerNode
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = ChannelMergerNode . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToChannelMergerNode :: IsGObject obj => obj -> IO ChannelMergerNode
-castToChannelMergerNode = castTo gTypeChannelMergerNode "ChannelMergerNode"
-
-foreign import javascript unsafe "window[\"ChannelMergerNode\"]" gTypeChannelMergerNode :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.ChannelSplitterNode".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.AudioNode"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/ChannelSplitterNode Mozilla ChannelSplitterNode documentation>
-newtype ChannelSplitterNode = ChannelSplitterNode { unChannelSplitterNode :: JSVal }
-
-instance Eq (ChannelSplitterNode) where
-  (ChannelSplitterNode a) == (ChannelSplitterNode b) = js_eq a b
-
-instance PToJSVal ChannelSplitterNode where
-  pToJSVal = unChannelSplitterNode
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal ChannelSplitterNode where
-  pFromJSVal = ChannelSplitterNode
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal ChannelSplitterNode where
-  toJSVal = return . unChannelSplitterNode
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal ChannelSplitterNode where
-  fromJSVal = return . fmap ChannelSplitterNode . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsAudioNode ChannelSplitterNode
-instance IsEventTarget ChannelSplitterNode
-instance IsGObject ChannelSplitterNode where
-  toGObject = GObject . unChannelSplitterNode
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = ChannelSplitterNode . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToChannelSplitterNode :: IsGObject obj => obj -> IO ChannelSplitterNode
-castToChannelSplitterNode = castTo gTypeChannelSplitterNode "ChannelSplitterNode"
-
-foreign import javascript unsafe "window[\"ChannelSplitterNode\"]" gTypeChannelSplitterNode :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.CharacterData".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/CharacterData Mozilla CharacterData documentation>
-newtype CharacterData = CharacterData { unCharacterData :: JSVal }
-
-instance Eq (CharacterData) where
-  (CharacterData a) == (CharacterData b) = js_eq a b
-
-instance PToJSVal CharacterData where
-  pToJSVal = unCharacterData
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal CharacterData where
-  pFromJSVal = CharacterData
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal CharacterData where
-  toJSVal = return . unCharacterData
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal CharacterData where
-  fromJSVal = return . fmap CharacterData . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-class IsNode o => IsCharacterData o
-toCharacterData :: IsCharacterData o => o -> CharacterData
-toCharacterData = unsafeCastGObject . toGObject
-
-instance IsCharacterData CharacterData
-instance IsNode CharacterData
-instance IsEventTarget CharacterData
-instance IsGObject CharacterData where
-  toGObject = GObject . unCharacterData
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = CharacterData . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToCharacterData :: IsGObject obj => obj -> IO CharacterData
-castToCharacterData = castTo gTypeCharacterData "CharacterData"
-
-foreign import javascript unsafe "window[\"CharacterData\"]" gTypeCharacterData :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.ChildNode".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/ChildNode Mozilla ChildNode documentation>
-newtype ChildNode = ChildNode { unChildNode :: JSVal }
-
-instance Eq (ChildNode) where
-  (ChildNode a) == (ChildNode b) = js_eq a b
-
-instance PToJSVal ChildNode where
-  pToJSVal = unChildNode
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal ChildNode where
-  pFromJSVal = ChildNode
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal ChildNode where
-  toJSVal = return . unChildNode
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal ChildNode where
-  fromJSVal = return . fmap ChildNode . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject ChildNode where
-  toGObject = GObject . unChildNode
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = ChildNode . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToChildNode :: IsGObject obj => obj -> IO ChildNode
-castToChildNode = castTo gTypeChildNode "ChildNode"
-
-foreign import javascript unsafe "window[\"ChildNode\"]" gTypeChildNode :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.ClientRect".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/ClientRect Mozilla ClientRect documentation>
-newtype ClientRect = ClientRect { unClientRect :: JSVal }
-
-instance Eq (ClientRect) where
-  (ClientRect a) == (ClientRect b) = js_eq a b
-
-instance PToJSVal ClientRect where
-  pToJSVal = unClientRect
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal ClientRect where
-  pFromJSVal = ClientRect
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal ClientRect where
-  toJSVal = return . unClientRect
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal ClientRect where
-  fromJSVal = return . fmap ClientRect . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject ClientRect where
-  toGObject = GObject . unClientRect
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = ClientRect . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToClientRect :: IsGObject obj => obj -> IO ClientRect
-castToClientRect = castTo gTypeClientRect "ClientRect"
-
-foreign import javascript unsafe "window[\"ClientRect\"]" gTypeClientRect :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.ClientRectList".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/ClientRectList Mozilla ClientRectList documentation>
-newtype ClientRectList = ClientRectList { unClientRectList :: JSVal }
-
-instance Eq (ClientRectList) where
-  (ClientRectList a) == (ClientRectList b) = js_eq a b
-
-instance PToJSVal ClientRectList where
-  pToJSVal = unClientRectList
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal ClientRectList where
-  pFromJSVal = ClientRectList
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal ClientRectList where
-  toJSVal = return . unClientRectList
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal ClientRectList where
-  fromJSVal = return . fmap ClientRectList . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject ClientRectList where
-  toGObject = GObject . unClientRectList
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = ClientRectList . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToClientRectList :: IsGObject obj => obj -> IO ClientRectList
-castToClientRectList = castTo gTypeClientRectList "ClientRectList"
-
-foreign import javascript unsafe "window[\"ClientRectList\"]" gTypeClientRectList :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.CloseEvent".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.Event"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/CloseEvent Mozilla CloseEvent documentation>
-newtype CloseEvent = CloseEvent { unCloseEvent :: JSVal }
-
-instance Eq (CloseEvent) where
-  (CloseEvent a) == (CloseEvent b) = js_eq a b
-
-instance PToJSVal CloseEvent where
-  pToJSVal = unCloseEvent
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal CloseEvent where
-  pFromJSVal = CloseEvent
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal CloseEvent where
-  toJSVal = return . unCloseEvent
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal CloseEvent where
-  fromJSVal = return . fmap CloseEvent . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsEvent CloseEvent
-instance IsGObject CloseEvent where
-  toGObject = GObject . unCloseEvent
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = CloseEvent . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToCloseEvent :: IsGObject obj => obj -> IO CloseEvent
-castToCloseEvent = castTo gTypeCloseEvent "CloseEvent"
-
-foreign import javascript unsafe "window[\"CloseEvent\"]" gTypeCloseEvent :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.CommandLineAPIHost".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/CommandLineAPIHost Mozilla CommandLineAPIHost documentation>
-newtype CommandLineAPIHost = CommandLineAPIHost { unCommandLineAPIHost :: JSVal }
-
-instance Eq (CommandLineAPIHost) where
-  (CommandLineAPIHost a) == (CommandLineAPIHost b) = js_eq a b
-
-instance PToJSVal CommandLineAPIHost where
-  pToJSVal = unCommandLineAPIHost
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal CommandLineAPIHost where
-  pFromJSVal = CommandLineAPIHost
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal CommandLineAPIHost where
-  toJSVal = return . unCommandLineAPIHost
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal CommandLineAPIHost where
-  fromJSVal = return . fmap CommandLineAPIHost . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject CommandLineAPIHost where
-  toGObject = GObject . unCommandLineAPIHost
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = CommandLineAPIHost . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToCommandLineAPIHost :: IsGObject obj => obj -> IO CommandLineAPIHost
-castToCommandLineAPIHost = castTo gTypeCommandLineAPIHost "CommandLineAPIHost"
-
-foreign import javascript unsafe "window[\"CommandLineAPIHost\"]" gTypeCommandLineAPIHost :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.Comment".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.CharacterData"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/Comment Mozilla Comment documentation>
-newtype Comment = Comment { unComment :: JSVal }
-
-instance Eq (Comment) where
-  (Comment a) == (Comment b) = js_eq a b
-
-instance PToJSVal Comment where
-  pToJSVal = unComment
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal Comment where
-  pFromJSVal = Comment
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal Comment where
-  toJSVal = return . unComment
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal Comment where
-  fromJSVal = return . fmap Comment . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsCharacterData Comment
-instance IsNode Comment
-instance IsEventTarget Comment
-instance IsGObject Comment where
-  toGObject = GObject . unComment
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = Comment . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToComment :: IsGObject obj => obj -> IO Comment
-castToComment = castTo gTypeComment "Comment"
-
-foreign import javascript unsafe "window[\"Comment\"]" gTypeComment :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.CompositionEvent".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.UIEvent"
---     * "GHCJS.DOM.Event"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/CompositionEvent Mozilla CompositionEvent documentation>
-newtype CompositionEvent = CompositionEvent { unCompositionEvent :: JSVal }
-
-instance Eq (CompositionEvent) where
-  (CompositionEvent a) == (CompositionEvent b) = js_eq a b
-
-instance PToJSVal CompositionEvent where
-  pToJSVal = unCompositionEvent
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal CompositionEvent where
-  pFromJSVal = CompositionEvent
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal CompositionEvent where
-  toJSVal = return . unCompositionEvent
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal CompositionEvent where
-  fromJSVal = return . fmap CompositionEvent . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsUIEvent CompositionEvent
-instance IsEvent CompositionEvent
-instance IsGObject CompositionEvent where
-  toGObject = GObject . unCompositionEvent
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = CompositionEvent . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToCompositionEvent :: IsGObject obj => obj -> IO CompositionEvent
-castToCompositionEvent = castTo gTypeCompositionEvent "CompositionEvent"
-
-foreign import javascript unsafe "window[\"CompositionEvent\"]" gTypeCompositionEvent :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.ConvolverNode".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.AudioNode"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/ConvolverNode Mozilla ConvolverNode documentation>
-newtype ConvolverNode = ConvolverNode { unConvolverNode :: JSVal }
-
-instance Eq (ConvolverNode) where
-  (ConvolverNode a) == (ConvolverNode b) = js_eq a b
-
-instance PToJSVal ConvolverNode where
-  pToJSVal = unConvolverNode
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal ConvolverNode where
-  pFromJSVal = ConvolverNode
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal ConvolverNode where
-  toJSVal = return . unConvolverNode
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal ConvolverNode where
-  fromJSVal = return . fmap ConvolverNode . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsAudioNode ConvolverNode
-instance IsEventTarget ConvolverNode
-instance IsGObject ConvolverNode where
-  toGObject = GObject . unConvolverNode
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = ConvolverNode . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToConvolverNode :: IsGObject obj => obj -> IO ConvolverNode
-castToConvolverNode = castTo gTypeConvolverNode "ConvolverNode"
-
-foreign import javascript unsafe "window[\"ConvolverNode\"]" gTypeConvolverNode :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.Coordinates".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/Coordinates Mozilla Coordinates documentation>
-newtype Coordinates = Coordinates { unCoordinates :: JSVal }
-
-instance Eq (Coordinates) where
-  (Coordinates a) == (Coordinates b) = js_eq a b
-
-instance PToJSVal Coordinates where
-  pToJSVal = unCoordinates
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal Coordinates where
-  pFromJSVal = Coordinates
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal Coordinates where
-  toJSVal = return . unCoordinates
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal Coordinates where
-  fromJSVal = return . fmap Coordinates . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject Coordinates where
-  toGObject = GObject . unCoordinates
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = Coordinates . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToCoordinates :: IsGObject obj => obj -> IO Coordinates
-castToCoordinates = castTo gTypeCoordinates "Coordinates"
-
-foreign import javascript unsafe "window[\"Coordinates\"]" gTypeCoordinates :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.Counter".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/Counter Mozilla Counter documentation>
-newtype Counter = Counter { unCounter :: JSVal }
-
-instance Eq (Counter) where
-  (Counter a) == (Counter b) = js_eq a b
-
-instance PToJSVal Counter where
-  pToJSVal = unCounter
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal Counter where
-  pFromJSVal = Counter
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal Counter where
-  toJSVal = return . unCounter
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal Counter where
-  fromJSVal = return . fmap Counter . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject Counter where
-  toGObject = GObject . unCounter
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = Counter . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToCounter :: IsGObject obj => obj -> IO Counter
-castToCounter = castTo gTypeCounter "Counter"
-
-foreign import javascript unsafe "window[\"Counter\"]" gTypeCounter :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.Crypto".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/Crypto Mozilla Crypto documentation>
-newtype Crypto = Crypto { unCrypto :: JSVal }
-
-instance Eq (Crypto) where
-  (Crypto a) == (Crypto b) = js_eq a b
-
-instance PToJSVal Crypto where
-  pToJSVal = unCrypto
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal Crypto where
-  pFromJSVal = Crypto
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal Crypto where
-  toJSVal = return . unCrypto
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal Crypto where
-  fromJSVal = return . fmap Crypto . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject Crypto where
-  toGObject = GObject . unCrypto
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = Crypto . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToCrypto :: IsGObject obj => obj -> IO Crypto
-castToCrypto = castTo gTypeCrypto "Crypto"
-
-foreign import javascript unsafe "window[\"Crypto\"]" gTypeCrypto :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.CryptoKey".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/CryptoKey Mozilla CryptoKey documentation>
-newtype CryptoKey = CryptoKey { unCryptoKey :: JSVal }
-
-instance Eq (CryptoKey) where
-  (CryptoKey a) == (CryptoKey b) = js_eq a b
-
-instance PToJSVal CryptoKey where
-  pToJSVal = unCryptoKey
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal CryptoKey where
-  pFromJSVal = CryptoKey
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal CryptoKey where
-  toJSVal = return . unCryptoKey
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal CryptoKey where
-  fromJSVal = return . fmap CryptoKey . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject CryptoKey where
-  toGObject = GObject . unCryptoKey
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = CryptoKey . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToCryptoKey :: IsGObject obj => obj -> IO CryptoKey
-castToCryptoKey = castTo gTypeCryptoKey "CryptoKey"
-
-foreign import javascript unsafe "window[\"CryptoKey\"]" gTypeCryptoKey :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.CryptoKeyPair".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/CryptoKeyPair Mozilla CryptoKeyPair documentation>
-newtype CryptoKeyPair = CryptoKeyPair { unCryptoKeyPair :: JSVal }
-
-instance Eq (CryptoKeyPair) where
-  (CryptoKeyPair a) == (CryptoKeyPair b) = js_eq a b
-
-instance PToJSVal CryptoKeyPair where
-  pToJSVal = unCryptoKeyPair
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal CryptoKeyPair where
-  pFromJSVal = CryptoKeyPair
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal CryptoKeyPair where
-  toJSVal = return . unCryptoKeyPair
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal CryptoKeyPair where
-  fromJSVal = return . fmap CryptoKeyPair . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject CryptoKeyPair where
-  toGObject = GObject . unCryptoKeyPair
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = CryptoKeyPair . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToCryptoKeyPair :: IsGObject obj => obj -> IO CryptoKeyPair
-castToCryptoKeyPair = castTo gTypeCryptoKeyPair "CryptoKeyPair"
-
-foreign import javascript unsafe "window[\"CryptoKeyPair\"]" gTypeCryptoKeyPair :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.CustomEvent".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.Event"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/CustomEvent Mozilla CustomEvent documentation>
-newtype CustomEvent = CustomEvent { unCustomEvent :: JSVal }
-
-instance Eq (CustomEvent) where
-  (CustomEvent a) == (CustomEvent b) = js_eq a b
-
-instance PToJSVal CustomEvent where
-  pToJSVal = unCustomEvent
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal CustomEvent where
-  pFromJSVal = CustomEvent
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal CustomEvent where
-  toJSVal = return . unCustomEvent
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal CustomEvent where
-  fromJSVal = return . fmap CustomEvent . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsEvent CustomEvent
-instance IsGObject CustomEvent where
-  toGObject = GObject . unCustomEvent
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = CustomEvent . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToCustomEvent :: IsGObject obj => obj -> IO CustomEvent
-castToCustomEvent = castTo gTypeCustomEvent "CustomEvent"
-
-foreign import javascript unsafe "window[\"CustomEvent\"]" gTypeCustomEvent :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.DOMError".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/DOMError Mozilla DOMError documentation>
-newtype DOMError = DOMError { unDOMError :: JSVal }
-
-instance Eq (DOMError) where
-  (DOMError a) == (DOMError b) = js_eq a b
-
-instance PToJSVal DOMError where
-  pToJSVal = unDOMError
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal DOMError where
-  pFromJSVal = DOMError
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal DOMError where
-  toJSVal = return . unDOMError
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal DOMError where
-  fromJSVal = return . fmap DOMError . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-class IsGObject o => IsDOMError o
-toDOMError :: IsDOMError o => o -> DOMError
-toDOMError = unsafeCastGObject . toGObject
-
-instance IsDOMError DOMError
-instance IsGObject DOMError where
-  toGObject = GObject . unDOMError
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = DOMError . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToDOMError :: IsGObject obj => obj -> IO DOMError
-castToDOMError = castTo gTypeDOMError "DOMError"
-
-foreign import javascript unsafe "window[\"DOMError\"]" gTypeDOMError :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.DOMImplementation".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/DOMImplementation Mozilla DOMImplementation documentation>
-newtype DOMImplementation = DOMImplementation { unDOMImplementation :: JSVal }
-
-instance Eq (DOMImplementation) where
-  (DOMImplementation a) == (DOMImplementation b) = js_eq a b
-
-instance PToJSVal DOMImplementation where
-  pToJSVal = unDOMImplementation
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal DOMImplementation where
-  pFromJSVal = DOMImplementation
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal DOMImplementation where
-  toJSVal = return . unDOMImplementation
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal DOMImplementation where
-  fromJSVal = return . fmap DOMImplementation . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject DOMImplementation where
-  toGObject = GObject . unDOMImplementation
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = DOMImplementation . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToDOMImplementation :: IsGObject obj => obj -> IO DOMImplementation
-castToDOMImplementation = castTo gTypeDOMImplementation "DOMImplementation"
-
-foreign import javascript unsafe "window[\"DOMImplementation\"]" gTypeDOMImplementation :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.DOMNamedFlowCollection".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/WebKitNamedFlowCollection Mozilla WebKitNamedFlowCollection documentation>
-newtype DOMNamedFlowCollection = DOMNamedFlowCollection { unDOMNamedFlowCollection :: JSVal }
-
-instance Eq (DOMNamedFlowCollection) where
-  (DOMNamedFlowCollection a) == (DOMNamedFlowCollection b) = js_eq a b
-
-instance PToJSVal DOMNamedFlowCollection where
-  pToJSVal = unDOMNamedFlowCollection
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal DOMNamedFlowCollection where
-  pFromJSVal = DOMNamedFlowCollection
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal DOMNamedFlowCollection where
-  toJSVal = return . unDOMNamedFlowCollection
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal DOMNamedFlowCollection where
-  fromJSVal = return . fmap DOMNamedFlowCollection . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject DOMNamedFlowCollection where
-  toGObject = GObject . unDOMNamedFlowCollection
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = DOMNamedFlowCollection . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToDOMNamedFlowCollection :: IsGObject obj => obj -> IO DOMNamedFlowCollection
-castToDOMNamedFlowCollection = castTo gTypeDOMNamedFlowCollection "DOMNamedFlowCollection"
-
-foreign import javascript unsafe "window[\"WebKitNamedFlowCollection\"]" gTypeDOMNamedFlowCollection :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.DOMParser".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/DOMParser Mozilla DOMParser documentation>
-newtype DOMParser = DOMParser { unDOMParser :: JSVal }
-
-instance Eq (DOMParser) where
-  (DOMParser a) == (DOMParser b) = js_eq a b
-
-instance PToJSVal DOMParser where
-  pToJSVal = unDOMParser
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal DOMParser where
-  pFromJSVal = DOMParser
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal DOMParser where
-  toJSVal = return . unDOMParser
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal DOMParser where
-  fromJSVal = return . fmap DOMParser . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject DOMParser where
-  toGObject = GObject . unDOMParser
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = DOMParser . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToDOMParser :: IsGObject obj => obj -> IO DOMParser
-castToDOMParser = castTo gTypeDOMParser "DOMParser"
-
-foreign import javascript unsafe "window[\"DOMParser\"]" gTypeDOMParser :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.DOMSettableTokenList".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.DOMTokenList"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/DOMSettableTokenList Mozilla DOMSettableTokenList documentation>
-newtype DOMSettableTokenList = DOMSettableTokenList { unDOMSettableTokenList :: JSVal }
-
-instance Eq (DOMSettableTokenList) where
-  (DOMSettableTokenList a) == (DOMSettableTokenList b) = js_eq a b
-
-instance PToJSVal DOMSettableTokenList where
-  pToJSVal = unDOMSettableTokenList
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal DOMSettableTokenList where
-  pFromJSVal = DOMSettableTokenList
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal DOMSettableTokenList where
-  toJSVal = return . unDOMSettableTokenList
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal DOMSettableTokenList where
-  fromJSVal = return . fmap DOMSettableTokenList . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsDOMTokenList DOMSettableTokenList
-instance IsGObject DOMSettableTokenList where
-  toGObject = GObject . unDOMSettableTokenList
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = DOMSettableTokenList . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToDOMSettableTokenList :: IsGObject obj => obj -> IO DOMSettableTokenList
-castToDOMSettableTokenList = castTo gTypeDOMSettableTokenList "DOMSettableTokenList"
-
-foreign import javascript unsafe "window[\"DOMSettableTokenList\"]" gTypeDOMSettableTokenList :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.DOMStringList".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/DOMStringList Mozilla DOMStringList documentation>
-newtype DOMStringList = DOMStringList { unDOMStringList :: JSVal }
-
-instance Eq (DOMStringList) where
-  (DOMStringList a) == (DOMStringList b) = js_eq a b
-
-instance PToJSVal DOMStringList where
-  pToJSVal = unDOMStringList
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal DOMStringList where
-  pFromJSVal = DOMStringList
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal DOMStringList where
-  toJSVal = return . unDOMStringList
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal DOMStringList where
-  fromJSVal = return . fmap DOMStringList . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject DOMStringList where
-  toGObject = GObject . unDOMStringList
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = DOMStringList . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToDOMStringList :: IsGObject obj => obj -> IO DOMStringList
-castToDOMStringList = castTo gTypeDOMStringList "DOMStringList"
-
-foreign import javascript unsafe "window[\"DOMStringList\"]" gTypeDOMStringList :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.DOMStringMap".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/DOMStringMap Mozilla DOMStringMap documentation>
-newtype DOMStringMap = DOMStringMap { unDOMStringMap :: JSVal }
-
-instance Eq (DOMStringMap) where
-  (DOMStringMap a) == (DOMStringMap b) = js_eq a b
-
-instance PToJSVal DOMStringMap where
-  pToJSVal = unDOMStringMap
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal DOMStringMap where
-  pFromJSVal = DOMStringMap
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal DOMStringMap where
-  toJSVal = return . unDOMStringMap
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal DOMStringMap where
-  fromJSVal = return . fmap DOMStringMap . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject DOMStringMap where
-  toGObject = GObject . unDOMStringMap
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = DOMStringMap . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToDOMStringMap :: IsGObject obj => obj -> IO DOMStringMap
-castToDOMStringMap = castTo gTypeDOMStringMap "DOMStringMap"
-
-foreign import javascript unsafe "window[\"DOMStringMap\"]" gTypeDOMStringMap :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.DOMTokenList".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/DOMTokenList Mozilla DOMTokenList documentation>
-newtype DOMTokenList = DOMTokenList { unDOMTokenList :: JSVal }
-
-instance Eq (DOMTokenList) where
-  (DOMTokenList a) == (DOMTokenList b) = js_eq a b
-
-instance PToJSVal DOMTokenList where
-  pToJSVal = unDOMTokenList
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal DOMTokenList where
-  pFromJSVal = DOMTokenList
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal DOMTokenList where
-  toJSVal = return . unDOMTokenList
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal DOMTokenList where
-  fromJSVal = return . fmap DOMTokenList . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-class IsGObject o => IsDOMTokenList o
-toDOMTokenList :: IsDOMTokenList o => o -> DOMTokenList
-toDOMTokenList = unsafeCastGObject . toGObject
-
-instance IsDOMTokenList DOMTokenList
-instance IsGObject DOMTokenList where
-  toGObject = GObject . unDOMTokenList
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = DOMTokenList . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToDOMTokenList :: IsGObject obj => obj -> IO DOMTokenList
-castToDOMTokenList = castTo gTypeDOMTokenList "DOMTokenList"
-
-foreign import javascript unsafe "window[\"DOMTokenList\"]" gTypeDOMTokenList :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.DataCue".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.TextTrackCue"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/WebKitDataCue Mozilla WebKitDataCue documentation>
-newtype DataCue = DataCue { unDataCue :: JSVal }
-
-instance Eq (DataCue) where
-  (DataCue a) == (DataCue b) = js_eq a b
-
-instance PToJSVal DataCue where
-  pToJSVal = unDataCue
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal DataCue where
-  pFromJSVal = DataCue
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal DataCue where
-  toJSVal = return . unDataCue
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal DataCue where
-  fromJSVal = return . fmap DataCue . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsTextTrackCue DataCue
-instance IsEventTarget DataCue
-instance IsGObject DataCue where
-  toGObject = GObject . unDataCue
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = DataCue . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToDataCue :: IsGObject obj => obj -> IO DataCue
-castToDataCue = castTo gTypeDataCue "DataCue"
-
-foreign import javascript unsafe "window[\"WebKitDataCue\"]" gTypeDataCue :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.DataTransfer".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/DataTransfer Mozilla DataTransfer documentation>
-newtype DataTransfer = DataTransfer { unDataTransfer :: JSVal }
-
-instance Eq (DataTransfer) where
-  (DataTransfer a) == (DataTransfer b) = js_eq a b
-
-instance PToJSVal DataTransfer where
-  pToJSVal = unDataTransfer
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal DataTransfer where
-  pFromJSVal = DataTransfer
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal DataTransfer where
-  toJSVal = return . unDataTransfer
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal DataTransfer where
-  fromJSVal = return . fmap DataTransfer . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject DataTransfer where
-  toGObject = GObject . unDataTransfer
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = DataTransfer . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToDataTransfer :: IsGObject obj => obj -> IO DataTransfer
-castToDataTransfer = castTo gTypeDataTransfer "DataTransfer"
-
-foreign import javascript unsafe "window[\"DataTransfer\"]" gTypeDataTransfer :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.DataTransferItem".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/DataTransferItem Mozilla DataTransferItem documentation>
-newtype DataTransferItem = DataTransferItem { unDataTransferItem :: JSVal }
-
-instance Eq (DataTransferItem) where
-  (DataTransferItem a) == (DataTransferItem b) = js_eq a b
-
-instance PToJSVal DataTransferItem where
-  pToJSVal = unDataTransferItem
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal DataTransferItem where
-  pFromJSVal = DataTransferItem
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal DataTransferItem where
-  toJSVal = return . unDataTransferItem
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal DataTransferItem where
-  fromJSVal = return . fmap DataTransferItem . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject DataTransferItem where
-  toGObject = GObject . unDataTransferItem
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = DataTransferItem . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToDataTransferItem :: IsGObject obj => obj -> IO DataTransferItem
-castToDataTransferItem = castTo gTypeDataTransferItem "DataTransferItem"
-
-foreign import javascript unsafe "window[\"DataTransferItem\"]" gTypeDataTransferItem :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.DataTransferItemList".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/DataTransferItemList Mozilla DataTransferItemList documentation>
-newtype DataTransferItemList = DataTransferItemList { unDataTransferItemList :: JSVal }
-
-instance Eq (DataTransferItemList) where
-  (DataTransferItemList a) == (DataTransferItemList b) = js_eq a b
-
-instance PToJSVal DataTransferItemList where
-  pToJSVal = unDataTransferItemList
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal DataTransferItemList where
-  pFromJSVal = DataTransferItemList
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal DataTransferItemList where
-  toJSVal = return . unDataTransferItemList
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal DataTransferItemList where
-  fromJSVal = return . fmap DataTransferItemList . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject DataTransferItemList where
-  toGObject = GObject . unDataTransferItemList
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = DataTransferItemList . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToDataTransferItemList :: IsGObject obj => obj -> IO DataTransferItemList
-castToDataTransferItemList = castTo gTypeDataTransferItemList "DataTransferItemList"
-
-foreign import javascript unsafe "window[\"DataTransferItemList\"]" gTypeDataTransferItemList :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.Database".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/Database Mozilla Database documentation>
-newtype Database = Database { unDatabase :: JSVal }
-
-instance Eq (Database) where
-  (Database a) == (Database b) = js_eq a b
-
-instance PToJSVal Database where
-  pToJSVal = unDatabase
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal Database where
-  pFromJSVal = Database
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal Database where
-  toJSVal = return . unDatabase
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal Database where
-  fromJSVal = return . fmap Database . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject Database where
-  toGObject = GObject . unDatabase
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = Database . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToDatabase :: IsGObject obj => obj -> IO Database
-castToDatabase = castTo gTypeDatabase "Database"
-
-foreign import javascript unsafe "window[\"Database\"]" gTypeDatabase :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.DedicatedWorkerGlobalScope".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.WorkerGlobalScope"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/DedicatedWorkerGlobalScope Mozilla DedicatedWorkerGlobalScope documentation>
-newtype DedicatedWorkerGlobalScope = DedicatedWorkerGlobalScope { unDedicatedWorkerGlobalScope :: JSVal }
-
-instance Eq (DedicatedWorkerGlobalScope) where
-  (DedicatedWorkerGlobalScope a) == (DedicatedWorkerGlobalScope b) = js_eq a b
-
-instance PToJSVal DedicatedWorkerGlobalScope where
-  pToJSVal = unDedicatedWorkerGlobalScope
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal DedicatedWorkerGlobalScope where
-  pFromJSVal = DedicatedWorkerGlobalScope
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal DedicatedWorkerGlobalScope where
-  toJSVal = return . unDedicatedWorkerGlobalScope
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal DedicatedWorkerGlobalScope where
-  fromJSVal = return . fmap DedicatedWorkerGlobalScope . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsWorkerGlobalScope DedicatedWorkerGlobalScope
-instance IsEventTarget DedicatedWorkerGlobalScope
-instance IsGObject DedicatedWorkerGlobalScope where
-  toGObject = GObject . unDedicatedWorkerGlobalScope
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = DedicatedWorkerGlobalScope . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToDedicatedWorkerGlobalScope :: IsGObject obj => obj -> IO DedicatedWorkerGlobalScope
-castToDedicatedWorkerGlobalScope = castTo gTypeDedicatedWorkerGlobalScope "DedicatedWorkerGlobalScope"
-
-foreign import javascript unsafe "window[\"DedicatedWorkerGlobalScope\"]" gTypeDedicatedWorkerGlobalScope :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.DelayNode".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.AudioNode"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/DelayNode Mozilla DelayNode documentation>
-newtype DelayNode = DelayNode { unDelayNode :: JSVal }
-
-instance Eq (DelayNode) where
-  (DelayNode a) == (DelayNode b) = js_eq a b
-
-instance PToJSVal DelayNode where
-  pToJSVal = unDelayNode
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal DelayNode where
-  pFromJSVal = DelayNode
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal DelayNode where
-  toJSVal = return . unDelayNode
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal DelayNode where
-  fromJSVal = return . fmap DelayNode . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsAudioNode DelayNode
-instance IsEventTarget DelayNode
-instance IsGObject DelayNode where
-  toGObject = GObject . unDelayNode
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = DelayNode . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToDelayNode :: IsGObject obj => obj -> IO DelayNode
-castToDelayNode = castTo gTypeDelayNode "DelayNode"
-
-foreign import javascript unsafe "window[\"DelayNode\"]" gTypeDelayNode :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.DeviceMotionEvent".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.Event"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/DeviceMotionEvent Mozilla DeviceMotionEvent documentation>
-newtype DeviceMotionEvent = DeviceMotionEvent { unDeviceMotionEvent :: JSVal }
-
-instance Eq (DeviceMotionEvent) where
-  (DeviceMotionEvent a) == (DeviceMotionEvent b) = js_eq a b
-
-instance PToJSVal DeviceMotionEvent where
-  pToJSVal = unDeviceMotionEvent
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal DeviceMotionEvent where
-  pFromJSVal = DeviceMotionEvent
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal DeviceMotionEvent where
-  toJSVal = return . unDeviceMotionEvent
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal DeviceMotionEvent where
-  fromJSVal = return . fmap DeviceMotionEvent . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsEvent DeviceMotionEvent
-instance IsGObject DeviceMotionEvent where
-  toGObject = GObject . unDeviceMotionEvent
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = DeviceMotionEvent . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToDeviceMotionEvent :: IsGObject obj => obj -> IO DeviceMotionEvent
-castToDeviceMotionEvent = castTo gTypeDeviceMotionEvent "DeviceMotionEvent"
-
-foreign import javascript unsafe "window[\"DeviceMotionEvent\"]" gTypeDeviceMotionEvent :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.DeviceOrientationEvent".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.Event"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/DeviceOrientationEvent Mozilla DeviceOrientationEvent documentation>
-newtype DeviceOrientationEvent = DeviceOrientationEvent { unDeviceOrientationEvent :: JSVal }
-
-instance Eq (DeviceOrientationEvent) where
-  (DeviceOrientationEvent a) == (DeviceOrientationEvent b) = js_eq a b
-
-instance PToJSVal DeviceOrientationEvent where
-  pToJSVal = unDeviceOrientationEvent
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal DeviceOrientationEvent where
-  pFromJSVal = DeviceOrientationEvent
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal DeviceOrientationEvent where
-  toJSVal = return . unDeviceOrientationEvent
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal DeviceOrientationEvent where
-  fromJSVal = return . fmap DeviceOrientationEvent . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsEvent DeviceOrientationEvent
-instance IsGObject DeviceOrientationEvent where
-  toGObject = GObject . unDeviceOrientationEvent
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = DeviceOrientationEvent . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToDeviceOrientationEvent :: IsGObject obj => obj -> IO DeviceOrientationEvent
-castToDeviceOrientationEvent = castTo gTypeDeviceOrientationEvent "DeviceOrientationEvent"
-
-foreign import javascript unsafe "window[\"DeviceOrientationEvent\"]" gTypeDeviceOrientationEvent :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.DeviceProximityEvent".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.Event"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/DeviceProximityEvent Mozilla DeviceProximityEvent documentation>
-newtype DeviceProximityEvent = DeviceProximityEvent { unDeviceProximityEvent :: JSVal }
-
-instance Eq (DeviceProximityEvent) where
-  (DeviceProximityEvent a) == (DeviceProximityEvent b) = js_eq a b
-
-instance PToJSVal DeviceProximityEvent where
-  pToJSVal = unDeviceProximityEvent
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal DeviceProximityEvent where
-  pFromJSVal = DeviceProximityEvent
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal DeviceProximityEvent where
-  toJSVal = return . unDeviceProximityEvent
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal DeviceProximityEvent where
-  fromJSVal = return . fmap DeviceProximityEvent . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsEvent DeviceProximityEvent
-instance IsGObject DeviceProximityEvent where
-  toGObject = GObject . unDeviceProximityEvent
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = DeviceProximityEvent . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToDeviceProximityEvent :: IsGObject obj => obj -> IO DeviceProximityEvent
-castToDeviceProximityEvent = castTo gTypeDeviceProximityEvent "DeviceProximityEvent"
-
-foreign import javascript unsafe "window[\"DeviceProximityEvent\"]" gTypeDeviceProximityEvent :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.Document".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/Document Mozilla Document documentation>
-newtype Document = Document { unDocument :: JSVal }
-
-instance Eq (Document) where
-  (Document a) == (Document b) = js_eq a b
-
-instance PToJSVal Document where
-  pToJSVal = unDocument
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal Document where
-  pFromJSVal = Document
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal Document where
-  toJSVal = return . unDocument
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal Document where
-  fromJSVal = return . fmap Document . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-class IsNode o => IsDocument o
-toDocument :: IsDocument o => o -> Document
-toDocument = unsafeCastGObject . toGObject
-
-instance IsDocument Document
-instance IsNode Document
-instance IsEventTarget Document
-instance IsGObject Document where
-  toGObject = GObject . unDocument
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = Document . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToDocument :: IsGObject obj => obj -> IO Document
-castToDocument = castTo gTypeDocument "Document"
-
-foreign import javascript unsafe "window[\"Document\"]" gTypeDocument :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.DocumentFragment".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/DocumentFragment Mozilla DocumentFragment documentation>
-newtype DocumentFragment = DocumentFragment { unDocumentFragment :: JSVal }
-
-instance Eq (DocumentFragment) where
-  (DocumentFragment a) == (DocumentFragment b) = js_eq a b
-
-instance PToJSVal DocumentFragment where
-  pToJSVal = unDocumentFragment
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal DocumentFragment where
-  pFromJSVal = DocumentFragment
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal DocumentFragment where
-  toJSVal = return . unDocumentFragment
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal DocumentFragment where
-  fromJSVal = return . fmap DocumentFragment . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsNode DocumentFragment
-instance IsEventTarget DocumentFragment
-instance IsGObject DocumentFragment where
-  toGObject = GObject . unDocumentFragment
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = DocumentFragment . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToDocumentFragment :: IsGObject obj => obj -> IO DocumentFragment
-castToDocumentFragment = castTo gTypeDocumentFragment "DocumentFragment"
-
-foreign import javascript unsafe "window[\"DocumentFragment\"]" gTypeDocumentFragment :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.DocumentType".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/DocumentType Mozilla DocumentType documentation>
-newtype DocumentType = DocumentType { unDocumentType :: JSVal }
-
-instance Eq (DocumentType) where
-  (DocumentType a) == (DocumentType b) = js_eq a b
-
-instance PToJSVal DocumentType where
-  pToJSVal = unDocumentType
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal DocumentType where
-  pFromJSVal = DocumentType
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal DocumentType where
-  toJSVal = return . unDocumentType
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal DocumentType where
-  fromJSVal = return . fmap DocumentType . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsNode DocumentType
-instance IsEventTarget DocumentType
-instance IsGObject DocumentType where
-  toGObject = GObject . unDocumentType
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = DocumentType . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToDocumentType :: IsGObject obj => obj -> IO DocumentType
-castToDocumentType = castTo gTypeDocumentType "DocumentType"
-
-foreign import javascript unsafe "window[\"DocumentType\"]" gTypeDocumentType :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.DynamicsCompressorNode".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.AudioNode"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/DynamicsCompressorNode Mozilla DynamicsCompressorNode documentation>
-newtype DynamicsCompressorNode = DynamicsCompressorNode { unDynamicsCompressorNode :: JSVal }
-
-instance Eq (DynamicsCompressorNode) where
-  (DynamicsCompressorNode a) == (DynamicsCompressorNode b) = js_eq a b
-
-instance PToJSVal DynamicsCompressorNode where
-  pToJSVal = unDynamicsCompressorNode
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal DynamicsCompressorNode where
-  pFromJSVal = DynamicsCompressorNode
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal DynamicsCompressorNode where
-  toJSVal = return . unDynamicsCompressorNode
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal DynamicsCompressorNode where
-  fromJSVal = return . fmap DynamicsCompressorNode . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsAudioNode DynamicsCompressorNode
-instance IsEventTarget DynamicsCompressorNode
-instance IsGObject DynamicsCompressorNode where
-  toGObject = GObject . unDynamicsCompressorNode
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = DynamicsCompressorNode . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToDynamicsCompressorNode :: IsGObject obj => obj -> IO DynamicsCompressorNode
-castToDynamicsCompressorNode = castTo gTypeDynamicsCompressorNode "DynamicsCompressorNode"
-
-foreign import javascript unsafe "window[\"DynamicsCompressorNode\"]" gTypeDynamicsCompressorNode :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.EXTBlendMinMax".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/EXTBlendMinMax Mozilla EXTBlendMinMax documentation>
-newtype EXTBlendMinMax = EXTBlendMinMax { unEXTBlendMinMax :: JSVal }
-
-instance Eq (EXTBlendMinMax) where
-  (EXTBlendMinMax a) == (EXTBlendMinMax b) = js_eq a b
-
-instance PToJSVal EXTBlendMinMax where
-  pToJSVal = unEXTBlendMinMax
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal EXTBlendMinMax where
-  pFromJSVal = EXTBlendMinMax
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal EXTBlendMinMax where
-  toJSVal = return . unEXTBlendMinMax
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal EXTBlendMinMax where
-  fromJSVal = return . fmap EXTBlendMinMax . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject EXTBlendMinMax where
-  toGObject = GObject . unEXTBlendMinMax
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = EXTBlendMinMax . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToEXTBlendMinMax :: IsGObject obj => obj -> IO EXTBlendMinMax
-castToEXTBlendMinMax = castTo gTypeEXTBlendMinMax "EXTBlendMinMax"
-
-foreign import javascript unsafe "window[\"EXTBlendMinMax\"]" gTypeEXTBlendMinMax :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.EXTFragDepth".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/EXTFragDepth Mozilla EXTFragDepth documentation>
-newtype EXTFragDepth = EXTFragDepth { unEXTFragDepth :: JSVal }
-
-instance Eq (EXTFragDepth) where
-  (EXTFragDepth a) == (EXTFragDepth b) = js_eq a b
-
-instance PToJSVal EXTFragDepth where
-  pToJSVal = unEXTFragDepth
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal EXTFragDepth where
-  pFromJSVal = EXTFragDepth
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal EXTFragDepth where
-  toJSVal = return . unEXTFragDepth
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal EXTFragDepth where
-  fromJSVal = return . fmap EXTFragDepth . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject EXTFragDepth where
-  toGObject = GObject . unEXTFragDepth
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = EXTFragDepth . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToEXTFragDepth :: IsGObject obj => obj -> IO EXTFragDepth
-castToEXTFragDepth = castTo gTypeEXTFragDepth "EXTFragDepth"
-
-foreign import javascript unsafe "window[\"EXTFragDepth\"]" gTypeEXTFragDepth :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.EXTShaderTextureLOD".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/EXTShaderTextureLOD Mozilla EXTShaderTextureLOD documentation>
-newtype EXTShaderTextureLOD = EXTShaderTextureLOD { unEXTShaderTextureLOD :: JSVal }
-
-instance Eq (EXTShaderTextureLOD) where
-  (EXTShaderTextureLOD a) == (EXTShaderTextureLOD b) = js_eq a b
-
-instance PToJSVal EXTShaderTextureLOD where
-  pToJSVal = unEXTShaderTextureLOD
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal EXTShaderTextureLOD where
-  pFromJSVal = EXTShaderTextureLOD
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal EXTShaderTextureLOD where
-  toJSVal = return . unEXTShaderTextureLOD
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal EXTShaderTextureLOD where
-  fromJSVal = return . fmap EXTShaderTextureLOD . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject EXTShaderTextureLOD where
-  toGObject = GObject . unEXTShaderTextureLOD
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = EXTShaderTextureLOD . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToEXTShaderTextureLOD :: IsGObject obj => obj -> IO EXTShaderTextureLOD
-castToEXTShaderTextureLOD = castTo gTypeEXTShaderTextureLOD "EXTShaderTextureLOD"
-
-foreign import javascript unsafe "window[\"EXTShaderTextureLOD\"]" gTypeEXTShaderTextureLOD :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.EXTTextureFilterAnisotropic".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/EXTTextureFilterAnisotropic Mozilla EXTTextureFilterAnisotropic documentation>
-newtype EXTTextureFilterAnisotropic = EXTTextureFilterAnisotropic { unEXTTextureFilterAnisotropic :: JSVal }
-
-instance Eq (EXTTextureFilterAnisotropic) where
-  (EXTTextureFilterAnisotropic a) == (EXTTextureFilterAnisotropic b) = js_eq a b
-
-instance PToJSVal EXTTextureFilterAnisotropic where
-  pToJSVal = unEXTTextureFilterAnisotropic
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal EXTTextureFilterAnisotropic where
-  pFromJSVal = EXTTextureFilterAnisotropic
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal EXTTextureFilterAnisotropic where
-  toJSVal = return . unEXTTextureFilterAnisotropic
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal EXTTextureFilterAnisotropic where
-  fromJSVal = return . fmap EXTTextureFilterAnisotropic . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject EXTTextureFilterAnisotropic where
-  toGObject = GObject . unEXTTextureFilterAnisotropic
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = EXTTextureFilterAnisotropic . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToEXTTextureFilterAnisotropic :: IsGObject obj => obj -> IO EXTTextureFilterAnisotropic
-castToEXTTextureFilterAnisotropic = castTo gTypeEXTTextureFilterAnisotropic "EXTTextureFilterAnisotropic"
-
-foreign import javascript unsafe "window[\"EXTTextureFilterAnisotropic\"]" gTypeEXTTextureFilterAnisotropic :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.EXTsRGB".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/EXTsRGB Mozilla EXTsRGB documentation>
-newtype EXTsRGB = EXTsRGB { unEXTsRGB :: JSVal }
-
-instance Eq (EXTsRGB) where
-  (EXTsRGB a) == (EXTsRGB b) = js_eq a b
-
-instance PToJSVal EXTsRGB where
-  pToJSVal = unEXTsRGB
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal EXTsRGB where
-  pFromJSVal = EXTsRGB
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal EXTsRGB where
-  toJSVal = return . unEXTsRGB
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal EXTsRGB where
-  fromJSVal = return . fmap EXTsRGB . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject EXTsRGB where
-  toGObject = GObject . unEXTsRGB
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = EXTsRGB . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToEXTsRGB :: IsGObject obj => obj -> IO EXTsRGB
-castToEXTsRGB = castTo gTypeEXTsRGB "EXTsRGB"
-
-foreign import javascript unsafe "window[\"EXTsRGB\"]" gTypeEXTsRGB :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.Element".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/Element Mozilla Element documentation>
-newtype Element = Element { unElement :: JSVal }
-
-instance Eq (Element) where
-  (Element a) == (Element b) = js_eq a b
-
-instance PToJSVal Element where
-  pToJSVal = unElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal Element where
-  pFromJSVal = Element
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal Element where
-  toJSVal = return . unElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal Element where
-  fromJSVal = return . fmap Element . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-class IsNode o => IsElement o
-toElement :: IsElement o => o -> Element
-toElement = unsafeCastGObject . toGObject
-
-instance IsElement Element
-instance IsNode Element
-instance IsEventTarget Element
-instance IsGObject Element where
-  toGObject = GObject . unElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = Element . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToElement :: IsGObject obj => obj -> IO Element
-castToElement = castTo gTypeElement "Element"
-
-foreign import javascript unsafe "window[\"Element\"]" gTypeElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.Entity".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/Entity Mozilla Entity documentation>
-newtype Entity = Entity { unEntity :: JSVal }
-
-instance Eq (Entity) where
-  (Entity a) == (Entity b) = js_eq a b
-
-instance PToJSVal Entity where
-  pToJSVal = unEntity
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal Entity where
-  pFromJSVal = Entity
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal Entity where
-  toJSVal = return . unEntity
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal Entity where
-  fromJSVal = return . fmap Entity . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsNode Entity
-instance IsEventTarget Entity
-instance IsGObject Entity where
-  toGObject = GObject . unEntity
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = Entity . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToEntity :: IsGObject obj => obj -> IO Entity
-castToEntity = castTo gTypeEntity "Entity"
-
-foreign import javascript unsafe "window[\"Entity\"]" gTypeEntity :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.EntityReference".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/EntityReference Mozilla EntityReference documentation>
-newtype EntityReference = EntityReference { unEntityReference :: JSVal }
-
-instance Eq (EntityReference) where
-  (EntityReference a) == (EntityReference b) = js_eq a b
-
-instance PToJSVal EntityReference where
-  pToJSVal = unEntityReference
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal EntityReference where
-  pFromJSVal = EntityReference
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal EntityReference where
-  toJSVal = return . unEntityReference
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal EntityReference where
-  fromJSVal = return . fmap EntityReference . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsNode EntityReference
-instance IsEventTarget EntityReference
-instance IsGObject EntityReference where
-  toGObject = GObject . unEntityReference
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = EntityReference . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToEntityReference :: IsGObject obj => obj -> IO EntityReference
-castToEntityReference = castTo gTypeEntityReference "EntityReference"
-
-foreign import javascript unsafe "window[\"EntityReference\"]" gTypeEntityReference :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.ErrorEvent".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.Event"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/ErrorEvent Mozilla ErrorEvent documentation>
-newtype ErrorEvent = ErrorEvent { unErrorEvent :: JSVal }
-
-instance Eq (ErrorEvent) where
-  (ErrorEvent a) == (ErrorEvent b) = js_eq a b
-
-instance PToJSVal ErrorEvent where
-  pToJSVal = unErrorEvent
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal ErrorEvent where
-  pFromJSVal = ErrorEvent
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal ErrorEvent where
-  toJSVal = return . unErrorEvent
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal ErrorEvent where
-  fromJSVal = return . fmap ErrorEvent . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsEvent ErrorEvent
-instance IsGObject ErrorEvent where
-  toGObject = GObject . unErrorEvent
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = ErrorEvent . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToErrorEvent :: IsGObject obj => obj -> IO ErrorEvent
-castToErrorEvent = castTo gTypeErrorEvent "ErrorEvent"
-
-foreign import javascript unsafe "window[\"ErrorEvent\"]" gTypeErrorEvent :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.Event".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/Event Mozilla Event documentation>
-newtype Event = Event { unEvent :: JSVal }
-
-instance Eq (Event) where
-  (Event a) == (Event b) = js_eq a b
-
-instance PToJSVal Event where
-  pToJSVal = unEvent
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal Event where
-  pFromJSVal = Event
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal Event where
-  toJSVal = return . unEvent
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal Event where
-  fromJSVal = return . fmap Event . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-class IsGObject o => IsEvent o
-toEvent :: IsEvent o => o -> Event
-toEvent = unsafeCastGObject . toGObject
-
-instance IsEvent Event
-instance IsGObject Event where
-  toGObject = GObject . unEvent
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = Event . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToEvent :: IsGObject obj => obj -> IO Event
-castToEvent = castTo gTypeEvent "Event"
-
-foreign import javascript unsafe "window[\"Event\"]" gTypeEvent :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.EventListener".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/EventListener Mozilla EventListener documentation>
-newtype EventListener = EventListener { unEventListener :: JSVal }
-
-instance Eq (EventListener) where
-  (EventListener a) == (EventListener b) = js_eq a b
-
-instance PToJSVal EventListener where
-  pToJSVal = unEventListener
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal EventListener where
-  pFromJSVal = EventListener
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal EventListener where
-  toJSVal = return . unEventListener
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal EventListener where
-  fromJSVal = return . fmap EventListener . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject EventListener where
-  toGObject = GObject . unEventListener
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = EventListener . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToEventListener :: IsGObject obj => obj -> IO EventListener
-castToEventListener = castTo gTypeEventListener "EventListener"
-
-foreign import javascript unsafe "window[\"EventListener\"]" gTypeEventListener :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.EventSource".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/EventSource Mozilla EventSource documentation>
-newtype EventSource = EventSource { unEventSource :: JSVal }
-
-instance Eq (EventSource) where
-  (EventSource a) == (EventSource b) = js_eq a b
-
-instance PToJSVal EventSource where
-  pToJSVal = unEventSource
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal EventSource where
-  pFromJSVal = EventSource
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal EventSource where
-  toJSVal = return . unEventSource
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal EventSource where
-  fromJSVal = return . fmap EventSource . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsEventTarget EventSource
-instance IsGObject EventSource where
-  toGObject = GObject . unEventSource
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = EventSource . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToEventSource :: IsGObject obj => obj -> IO EventSource
-castToEventSource = castTo gTypeEventSource "EventSource"
-
-foreign import javascript unsafe "window[\"EventSource\"]" gTypeEventSource :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.EventTarget".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/EventTarget Mozilla EventTarget documentation>
-newtype EventTarget = EventTarget { unEventTarget :: JSVal }
-
-instance Eq (EventTarget) where
-  (EventTarget a) == (EventTarget b) = js_eq a b
-
-instance PToJSVal EventTarget where
-  pToJSVal = unEventTarget
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal EventTarget where
-  pFromJSVal = EventTarget
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal EventTarget where
-  toJSVal = return . unEventTarget
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal EventTarget where
-  fromJSVal = return . fmap EventTarget . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-class IsGObject o => IsEventTarget o
-toEventTarget :: IsEventTarget o => o -> EventTarget
-toEventTarget = unsafeCastGObject . toGObject
-
-instance IsEventTarget EventTarget
-instance IsGObject EventTarget where
-  toGObject = GObject . unEventTarget
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = EventTarget . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToEventTarget :: IsGObject obj => obj -> IO EventTarget
-castToEventTarget = castTo gTypeEventTarget "EventTarget"
-
-foreign import javascript unsafe "window[\"EventTarget\"]" gTypeEventTarget :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.File".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.Blob"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/File Mozilla File documentation>
-newtype File = File { unFile :: JSVal }
-
-instance Eq (File) where
-  (File a) == (File b) = js_eq a b
-
-instance PToJSVal File where
-  pToJSVal = unFile
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal File where
-  pFromJSVal = File
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal File where
-  toJSVal = return . unFile
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal File where
-  fromJSVal = return . fmap File . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsBlob File
-instance IsGObject File where
-  toGObject = GObject . unFile
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = File . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToFile :: IsGObject obj => obj -> IO File
-castToFile = castTo gTypeFile "File"
-
-foreign import javascript unsafe "window[\"File\"]" gTypeFile :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.FileError".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/FileError Mozilla FileError documentation>
-newtype FileError = FileError { unFileError :: JSVal }
-
-instance Eq (FileError) where
-  (FileError a) == (FileError b) = js_eq a b
-
-instance PToJSVal FileError where
-  pToJSVal = unFileError
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal FileError where
-  pFromJSVal = FileError
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal FileError where
-  toJSVal = return . unFileError
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal FileError where
-  fromJSVal = return . fmap FileError . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject FileError where
-  toGObject = GObject . unFileError
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = FileError . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToFileError :: IsGObject obj => obj -> IO FileError
-castToFileError = castTo gTypeFileError "FileError"
-
-foreign import javascript unsafe "window[\"FileError\"]" gTypeFileError :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.FileList".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/FileList Mozilla FileList documentation>
-newtype FileList = FileList { unFileList :: JSVal }
-
-instance Eq (FileList) where
-  (FileList a) == (FileList b) = js_eq a b
-
-instance PToJSVal FileList where
-  pToJSVal = unFileList
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal FileList where
-  pFromJSVal = FileList
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal FileList where
-  toJSVal = return . unFileList
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal FileList where
-  fromJSVal = return . fmap FileList . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject FileList where
-  toGObject = GObject . unFileList
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = FileList . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToFileList :: IsGObject obj => obj -> IO FileList
-castToFileList = castTo gTypeFileList "FileList"
-
-foreign import javascript unsafe "window[\"FileList\"]" gTypeFileList :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.FileReader".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/FileReader Mozilla FileReader documentation>
-newtype FileReader = FileReader { unFileReader :: JSVal }
-
-instance Eq (FileReader) where
-  (FileReader a) == (FileReader b) = js_eq a b
-
-instance PToJSVal FileReader where
-  pToJSVal = unFileReader
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal FileReader where
-  pFromJSVal = FileReader
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal FileReader where
-  toJSVal = return . unFileReader
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal FileReader where
-  fromJSVal = return . fmap FileReader . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsEventTarget FileReader
-instance IsGObject FileReader where
-  toGObject = GObject . unFileReader
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = FileReader . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToFileReader :: IsGObject obj => obj -> IO FileReader
-castToFileReader = castTo gTypeFileReader "FileReader"
-
-foreign import javascript unsafe "window[\"FileReader\"]" gTypeFileReader :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.FileReaderSync".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/FileReaderSync Mozilla FileReaderSync documentation>
-newtype FileReaderSync = FileReaderSync { unFileReaderSync :: JSVal }
-
-instance Eq (FileReaderSync) where
-  (FileReaderSync a) == (FileReaderSync b) = js_eq a b
-
-instance PToJSVal FileReaderSync where
-  pToJSVal = unFileReaderSync
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal FileReaderSync where
-  pFromJSVal = FileReaderSync
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal FileReaderSync where
-  toJSVal = return . unFileReaderSync
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal FileReaderSync where
-  fromJSVal = return . fmap FileReaderSync . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject FileReaderSync where
-  toGObject = GObject . unFileReaderSync
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = FileReaderSync . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToFileReaderSync :: IsGObject obj => obj -> IO FileReaderSync
-castToFileReaderSync = castTo gTypeFileReaderSync "FileReaderSync"
-
-foreign import javascript unsafe "window[\"FileReaderSync\"]" gTypeFileReaderSync :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.FocusEvent".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.UIEvent"
---     * "GHCJS.DOM.Event"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/FocusEvent Mozilla FocusEvent documentation>
-newtype FocusEvent = FocusEvent { unFocusEvent :: JSVal }
-
-instance Eq (FocusEvent) where
-  (FocusEvent a) == (FocusEvent b) = js_eq a b
-
-instance PToJSVal FocusEvent where
-  pToJSVal = unFocusEvent
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal FocusEvent where
-  pFromJSVal = FocusEvent
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal FocusEvent where
-  toJSVal = return . unFocusEvent
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal FocusEvent where
-  fromJSVal = return . fmap FocusEvent . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsUIEvent FocusEvent
-instance IsEvent FocusEvent
-instance IsGObject FocusEvent where
-  toGObject = GObject . unFocusEvent
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = FocusEvent . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToFocusEvent :: IsGObject obj => obj -> IO FocusEvent
-castToFocusEvent = castTo gTypeFocusEvent "FocusEvent"
-
-foreign import javascript unsafe "window[\"FocusEvent\"]" gTypeFocusEvent :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.FontLoader".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/FontLoader Mozilla FontLoader documentation>
-newtype FontLoader = FontLoader { unFontLoader :: JSVal }
-
-instance Eq (FontLoader) where
-  (FontLoader a) == (FontLoader b) = js_eq a b
-
-instance PToJSVal FontLoader where
-  pToJSVal = unFontLoader
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal FontLoader where
-  pFromJSVal = FontLoader
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal FontLoader where
-  toJSVal = return . unFontLoader
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal FontLoader where
-  fromJSVal = return . fmap FontLoader . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsEventTarget FontLoader
-instance IsGObject FontLoader where
-  toGObject = GObject . unFontLoader
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = FontLoader . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToFontLoader :: IsGObject obj => obj -> IO FontLoader
-castToFontLoader = castTo gTypeFontLoader "FontLoader"
-
-foreign import javascript unsafe "window[\"FontLoader\"]" gTypeFontLoader :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.FormData".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/FormData Mozilla FormData documentation>
-newtype FormData = FormData { unFormData :: JSVal }
-
-instance Eq (FormData) where
-  (FormData a) == (FormData b) = js_eq a b
-
-instance PToJSVal FormData where
-  pToJSVal = unFormData
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal FormData where
-  pFromJSVal = FormData
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal FormData where
-  toJSVal = return . unFormData
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal FormData where
-  fromJSVal = return . fmap FormData . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject FormData where
-  toGObject = GObject . unFormData
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = FormData . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToFormData :: IsGObject obj => obj -> IO FormData
-castToFormData = castTo gTypeFormData "FormData"
-
-foreign import javascript unsafe "window[\"FormData\"]" gTypeFormData :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.GainNode".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.AudioNode"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/GainNode Mozilla GainNode documentation>
-newtype GainNode = GainNode { unGainNode :: JSVal }
-
-instance Eq (GainNode) where
-  (GainNode a) == (GainNode b) = js_eq a b
-
-instance PToJSVal GainNode where
-  pToJSVal = unGainNode
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal GainNode where
-  pFromJSVal = GainNode
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal GainNode where
-  toJSVal = return . unGainNode
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal GainNode where
-  fromJSVal = return . fmap GainNode . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsAudioNode GainNode
-instance IsEventTarget GainNode
-instance IsGObject GainNode where
-  toGObject = GObject . unGainNode
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = GainNode . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToGainNode :: IsGObject obj => obj -> IO GainNode
-castToGainNode = castTo gTypeGainNode "GainNode"
-
-foreign import javascript unsafe "window[\"GainNode\"]" gTypeGainNode :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.Gamepad".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/Gamepad Mozilla Gamepad documentation>
-newtype Gamepad = Gamepad { unGamepad :: JSVal }
-
-instance Eq (Gamepad) where
-  (Gamepad a) == (Gamepad b) = js_eq a b
-
-instance PToJSVal Gamepad where
-  pToJSVal = unGamepad
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal Gamepad where
-  pFromJSVal = Gamepad
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal Gamepad where
-  toJSVal = return . unGamepad
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal Gamepad where
-  fromJSVal = return . fmap Gamepad . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject Gamepad where
-  toGObject = GObject . unGamepad
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = Gamepad . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToGamepad :: IsGObject obj => obj -> IO Gamepad
-castToGamepad = castTo gTypeGamepad "Gamepad"
-
-foreign import javascript unsafe "window[\"Gamepad\"]" gTypeGamepad :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.GamepadButton".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/GamepadButton Mozilla GamepadButton documentation>
-newtype GamepadButton = GamepadButton { unGamepadButton :: JSVal }
-
-instance Eq (GamepadButton) where
-  (GamepadButton a) == (GamepadButton b) = js_eq a b
-
-instance PToJSVal GamepadButton where
-  pToJSVal = unGamepadButton
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal GamepadButton where
-  pFromJSVal = GamepadButton
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal GamepadButton where
-  toJSVal = return . unGamepadButton
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal GamepadButton where
-  fromJSVal = return . fmap GamepadButton . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject GamepadButton where
-  toGObject = GObject . unGamepadButton
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = GamepadButton . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToGamepadButton :: IsGObject obj => obj -> IO GamepadButton
-castToGamepadButton = castTo gTypeGamepadButton "GamepadButton"
-
-foreign import javascript unsafe "window[\"GamepadButton\"]" gTypeGamepadButton :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.GamepadEvent".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.Event"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/GamepadEvent Mozilla GamepadEvent documentation>
-newtype GamepadEvent = GamepadEvent { unGamepadEvent :: JSVal }
-
-instance Eq (GamepadEvent) where
-  (GamepadEvent a) == (GamepadEvent b) = js_eq a b
-
-instance PToJSVal GamepadEvent where
-  pToJSVal = unGamepadEvent
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal GamepadEvent where
-  pFromJSVal = GamepadEvent
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal GamepadEvent where
-  toJSVal = return . unGamepadEvent
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal GamepadEvent where
-  fromJSVal = return . fmap GamepadEvent . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsEvent GamepadEvent
-instance IsGObject GamepadEvent where
-  toGObject = GObject . unGamepadEvent
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = GamepadEvent . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToGamepadEvent :: IsGObject obj => obj -> IO GamepadEvent
-castToGamepadEvent = castTo gTypeGamepadEvent "GamepadEvent"
-
-foreign import javascript unsafe "window[\"GamepadEvent\"]" gTypeGamepadEvent :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.Geolocation".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/Geolocation Mozilla Geolocation documentation>
-newtype Geolocation = Geolocation { unGeolocation :: JSVal }
-
-instance Eq (Geolocation) where
-  (Geolocation a) == (Geolocation b) = js_eq a b
-
-instance PToJSVal Geolocation where
-  pToJSVal = unGeolocation
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal Geolocation where
-  pFromJSVal = Geolocation
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal Geolocation where
-  toJSVal = return . unGeolocation
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal Geolocation where
-  fromJSVal = return . fmap Geolocation . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject Geolocation where
-  toGObject = GObject . unGeolocation
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = Geolocation . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToGeolocation :: IsGObject obj => obj -> IO Geolocation
-castToGeolocation = castTo gTypeGeolocation "Geolocation"
-
-foreign import javascript unsafe "window[\"Geolocation\"]" gTypeGeolocation :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.Geoposition".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/Geoposition Mozilla Geoposition documentation>
-newtype Geoposition = Geoposition { unGeoposition :: JSVal }
-
-instance Eq (Geoposition) where
-  (Geoposition a) == (Geoposition b) = js_eq a b
-
-instance PToJSVal Geoposition where
-  pToJSVal = unGeoposition
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal Geoposition where
-  pFromJSVal = Geoposition
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal Geoposition where
-  toJSVal = return . unGeoposition
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal Geoposition where
-  fromJSVal = return . fmap Geoposition . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject Geoposition where
-  toGObject = GObject . unGeoposition
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = Geoposition . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToGeoposition :: IsGObject obj => obj -> IO Geoposition
-castToGeoposition = castTo gTypeGeoposition "Geoposition"
-
-foreign import javascript unsafe "window[\"Geoposition\"]" gTypeGeoposition :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.HTMLAllCollection".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/HTMLAllCollection Mozilla HTMLAllCollection documentation>
-newtype HTMLAllCollection = HTMLAllCollection { unHTMLAllCollection :: JSVal }
-
-instance Eq (HTMLAllCollection) where
-  (HTMLAllCollection a) == (HTMLAllCollection b) = js_eq a b
-
-instance PToJSVal HTMLAllCollection where
-  pToJSVal = unHTMLAllCollection
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal HTMLAllCollection where
-  pFromJSVal = HTMLAllCollection
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal HTMLAllCollection where
-  toJSVal = return . unHTMLAllCollection
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal HTMLAllCollection where
-  fromJSVal = return . fmap HTMLAllCollection . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject HTMLAllCollection where
-  toGObject = GObject . unHTMLAllCollection
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = HTMLAllCollection . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToHTMLAllCollection :: IsGObject obj => obj -> IO HTMLAllCollection
-castToHTMLAllCollection = castTo gTypeHTMLAllCollection "HTMLAllCollection"
-
-foreign import javascript unsafe "window[\"HTMLAllCollection\"]" gTypeHTMLAllCollection :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.HTMLAnchorElement".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.HTMLElement"
---     * "GHCJS.DOM.Element"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/HTMLAnchorElement Mozilla HTMLAnchorElement documentation>
-newtype HTMLAnchorElement = HTMLAnchorElement { unHTMLAnchorElement :: JSVal }
-
-instance Eq (HTMLAnchorElement) where
-  (HTMLAnchorElement a) == (HTMLAnchorElement b) = js_eq a b
-
-instance PToJSVal HTMLAnchorElement where
-  pToJSVal = unHTMLAnchorElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal HTMLAnchorElement where
-  pFromJSVal = HTMLAnchorElement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal HTMLAnchorElement where
-  toJSVal = return . unHTMLAnchorElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal HTMLAnchorElement where
-  fromJSVal = return . fmap HTMLAnchorElement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsHTMLElement HTMLAnchorElement
-instance IsElement HTMLAnchorElement
-instance IsNode HTMLAnchorElement
-instance IsEventTarget HTMLAnchorElement
-instance IsGObject HTMLAnchorElement where
-  toGObject = GObject . unHTMLAnchorElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = HTMLAnchorElement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToHTMLAnchorElement :: IsGObject obj => obj -> IO HTMLAnchorElement
-castToHTMLAnchorElement = castTo gTypeHTMLAnchorElement "HTMLAnchorElement"
-
-foreign import javascript unsafe "window[\"HTMLAnchorElement\"]" gTypeHTMLAnchorElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.HTMLAppletElement".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.HTMLElement"
---     * "GHCJS.DOM.Element"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/HTMLAppletElement Mozilla HTMLAppletElement documentation>
-newtype HTMLAppletElement = HTMLAppletElement { unHTMLAppletElement :: JSVal }
-
-instance Eq (HTMLAppletElement) where
-  (HTMLAppletElement a) == (HTMLAppletElement b) = js_eq a b
-
-instance PToJSVal HTMLAppletElement where
-  pToJSVal = unHTMLAppletElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal HTMLAppletElement where
-  pFromJSVal = HTMLAppletElement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal HTMLAppletElement where
-  toJSVal = return . unHTMLAppletElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal HTMLAppletElement where
-  fromJSVal = return . fmap HTMLAppletElement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsHTMLElement HTMLAppletElement
-instance IsElement HTMLAppletElement
-instance IsNode HTMLAppletElement
-instance IsEventTarget HTMLAppletElement
-instance IsGObject HTMLAppletElement where
-  toGObject = GObject . unHTMLAppletElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = HTMLAppletElement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToHTMLAppletElement :: IsGObject obj => obj -> IO HTMLAppletElement
-castToHTMLAppletElement = castTo gTypeHTMLAppletElement "HTMLAppletElement"
-
-foreign import javascript unsafe "window[\"HTMLAppletElement\"]" gTypeHTMLAppletElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.HTMLAreaElement".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.HTMLElement"
---     * "GHCJS.DOM.Element"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/HTMLAreaElement Mozilla HTMLAreaElement documentation>
-newtype HTMLAreaElement = HTMLAreaElement { unHTMLAreaElement :: JSVal }
-
-instance Eq (HTMLAreaElement) where
-  (HTMLAreaElement a) == (HTMLAreaElement b) = js_eq a b
-
-instance PToJSVal HTMLAreaElement where
-  pToJSVal = unHTMLAreaElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal HTMLAreaElement where
-  pFromJSVal = HTMLAreaElement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal HTMLAreaElement where
-  toJSVal = return . unHTMLAreaElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal HTMLAreaElement where
-  fromJSVal = return . fmap HTMLAreaElement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsHTMLElement HTMLAreaElement
-instance IsElement HTMLAreaElement
-instance IsNode HTMLAreaElement
-instance IsEventTarget HTMLAreaElement
-instance IsGObject HTMLAreaElement where
-  toGObject = GObject . unHTMLAreaElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = HTMLAreaElement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToHTMLAreaElement :: IsGObject obj => obj -> IO HTMLAreaElement
-castToHTMLAreaElement = castTo gTypeHTMLAreaElement "HTMLAreaElement"
-
-foreign import javascript unsafe "window[\"HTMLAreaElement\"]" gTypeHTMLAreaElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.HTMLAudioElement".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.HTMLMediaElement"
---     * "GHCJS.DOM.HTMLElement"
---     * "GHCJS.DOM.Element"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/HTMLAudioElement Mozilla HTMLAudioElement documentation>
-newtype HTMLAudioElement = HTMLAudioElement { unHTMLAudioElement :: JSVal }
-
-instance Eq (HTMLAudioElement) where
-  (HTMLAudioElement a) == (HTMLAudioElement b) = js_eq a b
-
-instance PToJSVal HTMLAudioElement where
-  pToJSVal = unHTMLAudioElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal HTMLAudioElement where
-  pFromJSVal = HTMLAudioElement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal HTMLAudioElement where
-  toJSVal = return . unHTMLAudioElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal HTMLAudioElement where
-  fromJSVal = return . fmap HTMLAudioElement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsHTMLMediaElement HTMLAudioElement
-instance IsHTMLElement HTMLAudioElement
-instance IsElement HTMLAudioElement
-instance IsNode HTMLAudioElement
-instance IsEventTarget HTMLAudioElement
-instance IsGObject HTMLAudioElement where
-  toGObject = GObject . unHTMLAudioElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = HTMLAudioElement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToHTMLAudioElement :: IsGObject obj => obj -> IO HTMLAudioElement
-castToHTMLAudioElement = castTo gTypeHTMLAudioElement "HTMLAudioElement"
-
-foreign import javascript unsafe "window[\"HTMLAudioElement\"]" gTypeHTMLAudioElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.HTMLBRElement".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.HTMLElement"
---     * "GHCJS.DOM.Element"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/HTMLBRElement Mozilla HTMLBRElement documentation>
-newtype HTMLBRElement = HTMLBRElement { unHTMLBRElement :: JSVal }
-
-instance Eq (HTMLBRElement) where
-  (HTMLBRElement a) == (HTMLBRElement b) = js_eq a b
-
-instance PToJSVal HTMLBRElement where
-  pToJSVal = unHTMLBRElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal HTMLBRElement where
-  pFromJSVal = HTMLBRElement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal HTMLBRElement where
-  toJSVal = return . unHTMLBRElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal HTMLBRElement where
-  fromJSVal = return . fmap HTMLBRElement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsHTMLElement HTMLBRElement
-instance IsElement HTMLBRElement
-instance IsNode HTMLBRElement
-instance IsEventTarget HTMLBRElement
-instance IsGObject HTMLBRElement where
-  toGObject = GObject . unHTMLBRElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = HTMLBRElement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToHTMLBRElement :: IsGObject obj => obj -> IO HTMLBRElement
-castToHTMLBRElement = castTo gTypeHTMLBRElement "HTMLBRElement"
-
-foreign import javascript unsafe "window[\"HTMLBRElement\"]" gTypeHTMLBRElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.HTMLBaseElement".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.HTMLElement"
---     * "GHCJS.DOM.Element"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/HTMLBaseElement Mozilla HTMLBaseElement documentation>
-newtype HTMLBaseElement = HTMLBaseElement { unHTMLBaseElement :: JSVal }
-
-instance Eq (HTMLBaseElement) where
-  (HTMLBaseElement a) == (HTMLBaseElement b) = js_eq a b
-
-instance PToJSVal HTMLBaseElement where
-  pToJSVal = unHTMLBaseElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal HTMLBaseElement where
-  pFromJSVal = HTMLBaseElement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal HTMLBaseElement where
-  toJSVal = return . unHTMLBaseElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal HTMLBaseElement where
-  fromJSVal = return . fmap HTMLBaseElement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsHTMLElement HTMLBaseElement
-instance IsElement HTMLBaseElement
-instance IsNode HTMLBaseElement
-instance IsEventTarget HTMLBaseElement
-instance IsGObject HTMLBaseElement where
-  toGObject = GObject . unHTMLBaseElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = HTMLBaseElement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToHTMLBaseElement :: IsGObject obj => obj -> IO HTMLBaseElement
-castToHTMLBaseElement = castTo gTypeHTMLBaseElement "HTMLBaseElement"
-
-foreign import javascript unsafe "window[\"HTMLBaseElement\"]" gTypeHTMLBaseElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.HTMLBaseFontElement".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.HTMLElement"
---     * "GHCJS.DOM.Element"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/HTMLBaseFontElement Mozilla HTMLBaseFontElement documentation>
-newtype HTMLBaseFontElement = HTMLBaseFontElement { unHTMLBaseFontElement :: JSVal }
-
-instance Eq (HTMLBaseFontElement) where
-  (HTMLBaseFontElement a) == (HTMLBaseFontElement b) = js_eq a b
-
-instance PToJSVal HTMLBaseFontElement where
-  pToJSVal = unHTMLBaseFontElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal HTMLBaseFontElement where
-  pFromJSVal = HTMLBaseFontElement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal HTMLBaseFontElement where
-  toJSVal = return . unHTMLBaseFontElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal HTMLBaseFontElement where
-  fromJSVal = return . fmap HTMLBaseFontElement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsHTMLElement HTMLBaseFontElement
-instance IsElement HTMLBaseFontElement
-instance IsNode HTMLBaseFontElement
-instance IsEventTarget HTMLBaseFontElement
-instance IsGObject HTMLBaseFontElement where
-  toGObject = GObject . unHTMLBaseFontElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = HTMLBaseFontElement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToHTMLBaseFontElement :: IsGObject obj => obj -> IO HTMLBaseFontElement
-castToHTMLBaseFontElement = castTo gTypeHTMLBaseFontElement "HTMLBaseFontElement"
-
-foreign import javascript unsafe "window[\"HTMLBaseFontElement\"]" gTypeHTMLBaseFontElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.HTMLBodyElement".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.HTMLElement"
---     * "GHCJS.DOM.Element"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/HTMLBodyElement Mozilla HTMLBodyElement documentation>
-newtype HTMLBodyElement = HTMLBodyElement { unHTMLBodyElement :: JSVal }
-
-instance Eq (HTMLBodyElement) where
-  (HTMLBodyElement a) == (HTMLBodyElement b) = js_eq a b
-
-instance PToJSVal HTMLBodyElement where
-  pToJSVal = unHTMLBodyElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal HTMLBodyElement where
-  pFromJSVal = HTMLBodyElement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal HTMLBodyElement where
-  toJSVal = return . unHTMLBodyElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal HTMLBodyElement where
-  fromJSVal = return . fmap HTMLBodyElement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsHTMLElement HTMLBodyElement
-instance IsElement HTMLBodyElement
-instance IsNode HTMLBodyElement
-instance IsEventTarget HTMLBodyElement
-instance IsGObject HTMLBodyElement where
-  toGObject = GObject . unHTMLBodyElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = HTMLBodyElement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToHTMLBodyElement :: IsGObject obj => obj -> IO HTMLBodyElement
-castToHTMLBodyElement = castTo gTypeHTMLBodyElement "HTMLBodyElement"
-
-foreign import javascript unsafe "window[\"HTMLBodyElement\"]" gTypeHTMLBodyElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.HTMLButtonElement".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.HTMLElement"
---     * "GHCJS.DOM.Element"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/HTMLButtonElement Mozilla HTMLButtonElement documentation>
-newtype HTMLButtonElement = HTMLButtonElement { unHTMLButtonElement :: JSVal }
-
-instance Eq (HTMLButtonElement) where
-  (HTMLButtonElement a) == (HTMLButtonElement b) = js_eq a b
-
-instance PToJSVal HTMLButtonElement where
-  pToJSVal = unHTMLButtonElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal HTMLButtonElement where
-  pFromJSVal = HTMLButtonElement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal HTMLButtonElement where
-  toJSVal = return . unHTMLButtonElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal HTMLButtonElement where
-  fromJSVal = return . fmap HTMLButtonElement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsHTMLElement HTMLButtonElement
-instance IsElement HTMLButtonElement
-instance IsNode HTMLButtonElement
-instance IsEventTarget HTMLButtonElement
-instance IsGObject HTMLButtonElement where
-  toGObject = GObject . unHTMLButtonElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = HTMLButtonElement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToHTMLButtonElement :: IsGObject obj => obj -> IO HTMLButtonElement
-castToHTMLButtonElement = castTo gTypeHTMLButtonElement "HTMLButtonElement"
-
-foreign import javascript unsafe "window[\"HTMLButtonElement\"]" gTypeHTMLButtonElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.HTMLCanvasElement".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.HTMLElement"
---     * "GHCJS.DOM.Element"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/HTMLCanvasElement Mozilla HTMLCanvasElement documentation>
-newtype HTMLCanvasElement = HTMLCanvasElement { unHTMLCanvasElement :: JSVal }
-
-instance Eq (HTMLCanvasElement) where
-  (HTMLCanvasElement a) == (HTMLCanvasElement b) = js_eq a b
-
-instance PToJSVal HTMLCanvasElement where
-  pToJSVal = unHTMLCanvasElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal HTMLCanvasElement where
-  pFromJSVal = HTMLCanvasElement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal HTMLCanvasElement where
-  toJSVal = return . unHTMLCanvasElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal HTMLCanvasElement where
-  fromJSVal = return . fmap HTMLCanvasElement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsHTMLElement HTMLCanvasElement
-instance IsElement HTMLCanvasElement
-instance IsNode HTMLCanvasElement
-instance IsEventTarget HTMLCanvasElement
-instance IsGObject HTMLCanvasElement where
-  toGObject = GObject . unHTMLCanvasElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = HTMLCanvasElement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToHTMLCanvasElement :: IsGObject obj => obj -> IO HTMLCanvasElement
-castToHTMLCanvasElement = castTo gTypeHTMLCanvasElement "HTMLCanvasElement"
-
-foreign import javascript unsafe "window[\"HTMLCanvasElement\"]" gTypeHTMLCanvasElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.HTMLCollection".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/HTMLCollection Mozilla HTMLCollection documentation>
-newtype HTMLCollection = HTMLCollection { unHTMLCollection :: JSVal }
-
-instance Eq (HTMLCollection) where
-  (HTMLCollection a) == (HTMLCollection b) = js_eq a b
-
-instance PToJSVal HTMLCollection where
-  pToJSVal = unHTMLCollection
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal HTMLCollection where
-  pFromJSVal = HTMLCollection
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal HTMLCollection where
-  toJSVal = return . unHTMLCollection
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal HTMLCollection where
-  fromJSVal = return . fmap HTMLCollection . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-class IsGObject o => IsHTMLCollection o
-toHTMLCollection :: IsHTMLCollection o => o -> HTMLCollection
-toHTMLCollection = unsafeCastGObject . toGObject
-
-instance IsHTMLCollection HTMLCollection
-instance IsGObject HTMLCollection where
-  toGObject = GObject . unHTMLCollection
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = HTMLCollection . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToHTMLCollection :: IsGObject obj => obj -> IO HTMLCollection
-castToHTMLCollection = castTo gTypeHTMLCollection "HTMLCollection"
-
-foreign import javascript unsafe "window[\"HTMLCollection\"]" gTypeHTMLCollection :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.HTMLDListElement".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.HTMLElement"
---     * "GHCJS.DOM.Element"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/HTMLDListElement Mozilla HTMLDListElement documentation>
-newtype HTMLDListElement = HTMLDListElement { unHTMLDListElement :: JSVal }
-
-instance Eq (HTMLDListElement) where
-  (HTMLDListElement a) == (HTMLDListElement b) = js_eq a b
-
-instance PToJSVal HTMLDListElement where
-  pToJSVal = unHTMLDListElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal HTMLDListElement where
-  pFromJSVal = HTMLDListElement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal HTMLDListElement where
-  toJSVal = return . unHTMLDListElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal HTMLDListElement where
-  fromJSVal = return . fmap HTMLDListElement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsHTMLElement HTMLDListElement
-instance IsElement HTMLDListElement
-instance IsNode HTMLDListElement
-instance IsEventTarget HTMLDListElement
-instance IsGObject HTMLDListElement where
-  toGObject = GObject . unHTMLDListElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = HTMLDListElement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToHTMLDListElement :: IsGObject obj => obj -> IO HTMLDListElement
-castToHTMLDListElement = castTo gTypeHTMLDListElement "HTMLDListElement"
-
-foreign import javascript unsafe "window[\"HTMLDListElement\"]" gTypeHTMLDListElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.HTMLDataListElement".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.HTMLElement"
---     * "GHCJS.DOM.Element"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/HTMLDataListElement Mozilla HTMLDataListElement documentation>
-newtype HTMLDataListElement = HTMLDataListElement { unHTMLDataListElement :: JSVal }
-
-instance Eq (HTMLDataListElement) where
-  (HTMLDataListElement a) == (HTMLDataListElement b) = js_eq a b
-
-instance PToJSVal HTMLDataListElement where
-  pToJSVal = unHTMLDataListElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal HTMLDataListElement where
-  pFromJSVal = HTMLDataListElement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal HTMLDataListElement where
-  toJSVal = return . unHTMLDataListElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal HTMLDataListElement where
-  fromJSVal = return . fmap HTMLDataListElement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsHTMLElement HTMLDataListElement
-instance IsElement HTMLDataListElement
-instance IsNode HTMLDataListElement
-instance IsEventTarget HTMLDataListElement
-instance IsGObject HTMLDataListElement where
-  toGObject = GObject . unHTMLDataListElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = HTMLDataListElement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToHTMLDataListElement :: IsGObject obj => obj -> IO HTMLDataListElement
-castToHTMLDataListElement = castTo gTypeHTMLDataListElement "HTMLDataListElement"
-
-foreign import javascript unsafe "window[\"HTMLDataListElement\"]" gTypeHTMLDataListElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.HTMLDetailsElement".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.HTMLElement"
---     * "GHCJS.DOM.Element"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/HTMLDetailsElement Mozilla HTMLDetailsElement documentation>
-newtype HTMLDetailsElement = HTMLDetailsElement { unHTMLDetailsElement :: JSVal }
-
-instance Eq (HTMLDetailsElement) where
-  (HTMLDetailsElement a) == (HTMLDetailsElement b) = js_eq a b
-
-instance PToJSVal HTMLDetailsElement where
-  pToJSVal = unHTMLDetailsElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal HTMLDetailsElement where
-  pFromJSVal = HTMLDetailsElement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal HTMLDetailsElement where
-  toJSVal = return . unHTMLDetailsElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal HTMLDetailsElement where
-  fromJSVal = return . fmap HTMLDetailsElement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsHTMLElement HTMLDetailsElement
-instance IsElement HTMLDetailsElement
-instance IsNode HTMLDetailsElement
-instance IsEventTarget HTMLDetailsElement
-instance IsGObject HTMLDetailsElement where
-  toGObject = GObject . unHTMLDetailsElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = HTMLDetailsElement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToHTMLDetailsElement :: IsGObject obj => obj -> IO HTMLDetailsElement
-castToHTMLDetailsElement = castTo gTypeHTMLDetailsElement "HTMLDetailsElement"
-
-foreign import javascript unsafe "window[\"HTMLDetailsElement\"]" gTypeHTMLDetailsElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.HTMLDirectoryElement".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.HTMLElement"
---     * "GHCJS.DOM.Element"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/HTMLDirectoryElement Mozilla HTMLDirectoryElement documentation>
-newtype HTMLDirectoryElement = HTMLDirectoryElement { unHTMLDirectoryElement :: JSVal }
-
-instance Eq (HTMLDirectoryElement) where
-  (HTMLDirectoryElement a) == (HTMLDirectoryElement b) = js_eq a b
-
-instance PToJSVal HTMLDirectoryElement where
-  pToJSVal = unHTMLDirectoryElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal HTMLDirectoryElement where
-  pFromJSVal = HTMLDirectoryElement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal HTMLDirectoryElement where
-  toJSVal = return . unHTMLDirectoryElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal HTMLDirectoryElement where
-  fromJSVal = return . fmap HTMLDirectoryElement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsHTMLElement HTMLDirectoryElement
-instance IsElement HTMLDirectoryElement
-instance IsNode HTMLDirectoryElement
-instance IsEventTarget HTMLDirectoryElement
-instance IsGObject HTMLDirectoryElement where
-  toGObject = GObject . unHTMLDirectoryElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = HTMLDirectoryElement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToHTMLDirectoryElement :: IsGObject obj => obj -> IO HTMLDirectoryElement
-castToHTMLDirectoryElement = castTo gTypeHTMLDirectoryElement "HTMLDirectoryElement"
-
-foreign import javascript unsafe "window[\"HTMLDirectoryElement\"]" gTypeHTMLDirectoryElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.HTMLDivElement".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.HTMLElement"
---     * "GHCJS.DOM.Element"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/HTMLDivElement Mozilla HTMLDivElement documentation>
-newtype HTMLDivElement = HTMLDivElement { unHTMLDivElement :: JSVal }
-
-instance Eq (HTMLDivElement) where
-  (HTMLDivElement a) == (HTMLDivElement b) = js_eq a b
-
-instance PToJSVal HTMLDivElement where
-  pToJSVal = unHTMLDivElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal HTMLDivElement where
-  pFromJSVal = HTMLDivElement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal HTMLDivElement where
-  toJSVal = return . unHTMLDivElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal HTMLDivElement where
-  fromJSVal = return . fmap HTMLDivElement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsHTMLElement HTMLDivElement
-instance IsElement HTMLDivElement
-instance IsNode HTMLDivElement
-instance IsEventTarget HTMLDivElement
-instance IsGObject HTMLDivElement where
-  toGObject = GObject . unHTMLDivElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = HTMLDivElement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToHTMLDivElement :: IsGObject obj => obj -> IO HTMLDivElement
-castToHTMLDivElement = castTo gTypeHTMLDivElement "HTMLDivElement"
-
-foreign import javascript unsafe "window[\"HTMLDivElement\"]" gTypeHTMLDivElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.HTMLDocument".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.Document"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/HTMLDocument Mozilla HTMLDocument documentation>
-newtype HTMLDocument = HTMLDocument { unHTMLDocument :: JSVal }
-
-instance Eq (HTMLDocument) where
-  (HTMLDocument a) == (HTMLDocument b) = js_eq a b
-
-instance PToJSVal HTMLDocument where
-  pToJSVal = unHTMLDocument
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal HTMLDocument where
-  pFromJSVal = HTMLDocument
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal HTMLDocument where
-  toJSVal = return . unHTMLDocument
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal HTMLDocument where
-  fromJSVal = return . fmap HTMLDocument . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsDocument HTMLDocument
-instance IsNode HTMLDocument
-instance IsEventTarget HTMLDocument
-instance IsGObject HTMLDocument where
-  toGObject = GObject . unHTMLDocument
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = HTMLDocument . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToHTMLDocument :: IsGObject obj => obj -> IO HTMLDocument
-castToHTMLDocument = castTo gTypeHTMLDocument "HTMLDocument"
-
-foreign import javascript unsafe "window[\"HTMLDocument\"]" gTypeHTMLDocument :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.HTMLElement".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.Element"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement Mozilla HTMLElement documentation>
-newtype HTMLElement = HTMLElement { unHTMLElement :: JSVal }
-
-instance Eq (HTMLElement) where
-  (HTMLElement a) == (HTMLElement b) = js_eq a b
-
-instance PToJSVal HTMLElement where
-  pToJSVal = unHTMLElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal HTMLElement where
-  pFromJSVal = HTMLElement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal HTMLElement where
-  toJSVal = return . unHTMLElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal HTMLElement where
-  fromJSVal = return . fmap HTMLElement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-class IsElement o => IsHTMLElement o
-toHTMLElement :: IsHTMLElement o => o -> HTMLElement
-toHTMLElement = unsafeCastGObject . toGObject
-
-instance IsHTMLElement HTMLElement
-instance IsElement HTMLElement
-instance IsNode HTMLElement
-instance IsEventTarget HTMLElement
-instance IsGObject HTMLElement where
-  toGObject = GObject . unHTMLElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = HTMLElement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToHTMLElement :: IsGObject obj => obj -> IO HTMLElement
-castToHTMLElement = castTo gTypeHTMLElement "HTMLElement"
-
-foreign import javascript unsafe "window[\"HTMLElement\"]" gTypeHTMLElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.HTMLEmbedElement".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.HTMLElement"
---     * "GHCJS.DOM.Element"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/HTMLEmbedElement Mozilla HTMLEmbedElement documentation>
-newtype HTMLEmbedElement = HTMLEmbedElement { unHTMLEmbedElement :: JSVal }
-
-instance Eq (HTMLEmbedElement) where
-  (HTMLEmbedElement a) == (HTMLEmbedElement b) = js_eq a b
-
-instance PToJSVal HTMLEmbedElement where
-  pToJSVal = unHTMLEmbedElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal HTMLEmbedElement where
-  pFromJSVal = HTMLEmbedElement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal HTMLEmbedElement where
-  toJSVal = return . unHTMLEmbedElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal HTMLEmbedElement where
-  fromJSVal = return . fmap HTMLEmbedElement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsHTMLElement HTMLEmbedElement
-instance IsElement HTMLEmbedElement
-instance IsNode HTMLEmbedElement
-instance IsEventTarget HTMLEmbedElement
-instance IsGObject HTMLEmbedElement where
-  toGObject = GObject . unHTMLEmbedElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = HTMLEmbedElement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToHTMLEmbedElement :: IsGObject obj => obj -> IO HTMLEmbedElement
-castToHTMLEmbedElement = castTo gTypeHTMLEmbedElement "HTMLEmbedElement"
-
-foreign import javascript unsafe "window[\"HTMLEmbedElement\"]" gTypeHTMLEmbedElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.HTMLFieldSetElement".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.HTMLElement"
---     * "GHCJS.DOM.Element"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/HTMLFieldSetElement Mozilla HTMLFieldSetElement documentation>
-newtype HTMLFieldSetElement = HTMLFieldSetElement { unHTMLFieldSetElement :: JSVal }
-
-instance Eq (HTMLFieldSetElement) where
-  (HTMLFieldSetElement a) == (HTMLFieldSetElement b) = js_eq a b
-
-instance PToJSVal HTMLFieldSetElement where
-  pToJSVal = unHTMLFieldSetElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal HTMLFieldSetElement where
-  pFromJSVal = HTMLFieldSetElement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal HTMLFieldSetElement where
-  toJSVal = return . unHTMLFieldSetElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal HTMLFieldSetElement where
-  fromJSVal = return . fmap HTMLFieldSetElement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsHTMLElement HTMLFieldSetElement
-instance IsElement HTMLFieldSetElement
-instance IsNode HTMLFieldSetElement
-instance IsEventTarget HTMLFieldSetElement
-instance IsGObject HTMLFieldSetElement where
-  toGObject = GObject . unHTMLFieldSetElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = HTMLFieldSetElement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToHTMLFieldSetElement :: IsGObject obj => obj -> IO HTMLFieldSetElement
-castToHTMLFieldSetElement = castTo gTypeHTMLFieldSetElement "HTMLFieldSetElement"
-
-foreign import javascript unsafe "window[\"HTMLFieldSetElement\"]" gTypeHTMLFieldSetElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.HTMLFontElement".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.HTMLElement"
---     * "GHCJS.DOM.Element"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/HTMLFontElement Mozilla HTMLFontElement documentation>
-newtype HTMLFontElement = HTMLFontElement { unHTMLFontElement :: JSVal }
-
-instance Eq (HTMLFontElement) where
-  (HTMLFontElement a) == (HTMLFontElement b) = js_eq a b
-
-instance PToJSVal HTMLFontElement where
-  pToJSVal = unHTMLFontElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal HTMLFontElement where
-  pFromJSVal = HTMLFontElement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal HTMLFontElement where
-  toJSVal = return . unHTMLFontElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal HTMLFontElement where
-  fromJSVal = return . fmap HTMLFontElement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsHTMLElement HTMLFontElement
-instance IsElement HTMLFontElement
-instance IsNode HTMLFontElement
-instance IsEventTarget HTMLFontElement
-instance IsGObject HTMLFontElement where
-  toGObject = GObject . unHTMLFontElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = HTMLFontElement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToHTMLFontElement :: IsGObject obj => obj -> IO HTMLFontElement
-castToHTMLFontElement = castTo gTypeHTMLFontElement "HTMLFontElement"
-
-foreign import javascript unsafe "window[\"HTMLFontElement\"]" gTypeHTMLFontElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.HTMLFormControlsCollection".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.HTMLCollection"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/HTMLFormControlsCollection Mozilla HTMLFormControlsCollection documentation>
-newtype HTMLFormControlsCollection = HTMLFormControlsCollection { unHTMLFormControlsCollection :: JSVal }
-
-instance Eq (HTMLFormControlsCollection) where
-  (HTMLFormControlsCollection a) == (HTMLFormControlsCollection b) = js_eq a b
-
-instance PToJSVal HTMLFormControlsCollection where
-  pToJSVal = unHTMLFormControlsCollection
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal HTMLFormControlsCollection where
-  pFromJSVal = HTMLFormControlsCollection
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal HTMLFormControlsCollection where
-  toJSVal = return . unHTMLFormControlsCollection
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal HTMLFormControlsCollection where
-  fromJSVal = return . fmap HTMLFormControlsCollection . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsHTMLCollection HTMLFormControlsCollection
-instance IsGObject HTMLFormControlsCollection where
-  toGObject = GObject . unHTMLFormControlsCollection
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = HTMLFormControlsCollection . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToHTMLFormControlsCollection :: IsGObject obj => obj -> IO HTMLFormControlsCollection
-castToHTMLFormControlsCollection = castTo gTypeHTMLFormControlsCollection "HTMLFormControlsCollection"
-
-foreign import javascript unsafe "window[\"HTMLFormControlsCollection\"]" gTypeHTMLFormControlsCollection :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.HTMLFormElement".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.HTMLElement"
---     * "GHCJS.DOM.Element"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/HTMLFormElement Mozilla HTMLFormElement documentation>
-newtype HTMLFormElement = HTMLFormElement { unHTMLFormElement :: JSVal }
-
-instance Eq (HTMLFormElement) where
-  (HTMLFormElement a) == (HTMLFormElement b) = js_eq a b
-
-instance PToJSVal HTMLFormElement where
-  pToJSVal = unHTMLFormElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal HTMLFormElement where
-  pFromJSVal = HTMLFormElement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal HTMLFormElement where
-  toJSVal = return . unHTMLFormElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal HTMLFormElement where
-  fromJSVal = return . fmap HTMLFormElement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsHTMLElement HTMLFormElement
-instance IsElement HTMLFormElement
-instance IsNode HTMLFormElement
-instance IsEventTarget HTMLFormElement
-instance IsGObject HTMLFormElement where
-  toGObject = GObject . unHTMLFormElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = HTMLFormElement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToHTMLFormElement :: IsGObject obj => obj -> IO HTMLFormElement
-castToHTMLFormElement = castTo gTypeHTMLFormElement "HTMLFormElement"
-
-foreign import javascript unsafe "window[\"HTMLFormElement\"]" gTypeHTMLFormElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.HTMLFrameElement".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.HTMLElement"
---     * "GHCJS.DOM.Element"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/HTMLFrameElement Mozilla HTMLFrameElement documentation>
-newtype HTMLFrameElement = HTMLFrameElement { unHTMLFrameElement :: JSVal }
-
-instance Eq (HTMLFrameElement) where
-  (HTMLFrameElement a) == (HTMLFrameElement b) = js_eq a b
-
-instance PToJSVal HTMLFrameElement where
-  pToJSVal = unHTMLFrameElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal HTMLFrameElement where
-  pFromJSVal = HTMLFrameElement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal HTMLFrameElement where
-  toJSVal = return . unHTMLFrameElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal HTMLFrameElement where
-  fromJSVal = return . fmap HTMLFrameElement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsHTMLElement HTMLFrameElement
-instance IsElement HTMLFrameElement
-instance IsNode HTMLFrameElement
-instance IsEventTarget HTMLFrameElement
-instance IsGObject HTMLFrameElement where
-  toGObject = GObject . unHTMLFrameElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = HTMLFrameElement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToHTMLFrameElement :: IsGObject obj => obj -> IO HTMLFrameElement
-castToHTMLFrameElement = castTo gTypeHTMLFrameElement "HTMLFrameElement"
-
-foreign import javascript unsafe "window[\"HTMLFrameElement\"]" gTypeHTMLFrameElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.HTMLFrameSetElement".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.HTMLElement"
---     * "GHCJS.DOM.Element"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/HTMLFrameSetElement Mozilla HTMLFrameSetElement documentation>
-newtype HTMLFrameSetElement = HTMLFrameSetElement { unHTMLFrameSetElement :: JSVal }
-
-instance Eq (HTMLFrameSetElement) where
-  (HTMLFrameSetElement a) == (HTMLFrameSetElement b) = js_eq a b
-
-instance PToJSVal HTMLFrameSetElement where
-  pToJSVal = unHTMLFrameSetElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal HTMLFrameSetElement where
-  pFromJSVal = HTMLFrameSetElement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal HTMLFrameSetElement where
-  toJSVal = return . unHTMLFrameSetElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal HTMLFrameSetElement where
-  fromJSVal = return . fmap HTMLFrameSetElement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsHTMLElement HTMLFrameSetElement
-instance IsElement HTMLFrameSetElement
-instance IsNode HTMLFrameSetElement
-instance IsEventTarget HTMLFrameSetElement
-instance IsGObject HTMLFrameSetElement where
-  toGObject = GObject . unHTMLFrameSetElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = HTMLFrameSetElement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToHTMLFrameSetElement :: IsGObject obj => obj -> IO HTMLFrameSetElement
-castToHTMLFrameSetElement = castTo gTypeHTMLFrameSetElement "HTMLFrameSetElement"
-
-foreign import javascript unsafe "window[\"HTMLFrameSetElement\"]" gTypeHTMLFrameSetElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.HTMLHRElement".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.HTMLElement"
---     * "GHCJS.DOM.Element"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/HTMLHRElement Mozilla HTMLHRElement documentation>
-newtype HTMLHRElement = HTMLHRElement { unHTMLHRElement :: JSVal }
-
-instance Eq (HTMLHRElement) where
-  (HTMLHRElement a) == (HTMLHRElement b) = js_eq a b
-
-instance PToJSVal HTMLHRElement where
-  pToJSVal = unHTMLHRElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal HTMLHRElement where
-  pFromJSVal = HTMLHRElement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal HTMLHRElement where
-  toJSVal = return . unHTMLHRElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal HTMLHRElement where
-  fromJSVal = return . fmap HTMLHRElement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsHTMLElement HTMLHRElement
-instance IsElement HTMLHRElement
-instance IsNode HTMLHRElement
-instance IsEventTarget HTMLHRElement
-instance IsGObject HTMLHRElement where
-  toGObject = GObject . unHTMLHRElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = HTMLHRElement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToHTMLHRElement :: IsGObject obj => obj -> IO HTMLHRElement
-castToHTMLHRElement = castTo gTypeHTMLHRElement "HTMLHRElement"
-
-foreign import javascript unsafe "window[\"HTMLHRElement\"]" gTypeHTMLHRElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.HTMLHeadElement".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.HTMLElement"
---     * "GHCJS.DOM.Element"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/HTMLHeadElement Mozilla HTMLHeadElement documentation>
-newtype HTMLHeadElement = HTMLHeadElement { unHTMLHeadElement :: JSVal }
-
-instance Eq (HTMLHeadElement) where
-  (HTMLHeadElement a) == (HTMLHeadElement b) = js_eq a b
-
-instance PToJSVal HTMLHeadElement where
-  pToJSVal = unHTMLHeadElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal HTMLHeadElement where
-  pFromJSVal = HTMLHeadElement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal HTMLHeadElement where
-  toJSVal = return . unHTMLHeadElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal HTMLHeadElement where
-  fromJSVal = return . fmap HTMLHeadElement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsHTMLElement HTMLHeadElement
-instance IsElement HTMLHeadElement
-instance IsNode HTMLHeadElement
-instance IsEventTarget HTMLHeadElement
-instance IsGObject HTMLHeadElement where
-  toGObject = GObject . unHTMLHeadElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = HTMLHeadElement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToHTMLHeadElement :: IsGObject obj => obj -> IO HTMLHeadElement
-castToHTMLHeadElement = castTo gTypeHTMLHeadElement "HTMLHeadElement"
-
-foreign import javascript unsafe "window[\"HTMLHeadElement\"]" gTypeHTMLHeadElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.HTMLHeadingElement".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.HTMLElement"
---     * "GHCJS.DOM.Element"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/HTMLHeadingElement Mozilla HTMLHeadingElement documentation>
-newtype HTMLHeadingElement = HTMLHeadingElement { unHTMLHeadingElement :: JSVal }
-
-instance Eq (HTMLHeadingElement) where
-  (HTMLHeadingElement a) == (HTMLHeadingElement b) = js_eq a b
-
-instance PToJSVal HTMLHeadingElement where
-  pToJSVal = unHTMLHeadingElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal HTMLHeadingElement where
-  pFromJSVal = HTMLHeadingElement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal HTMLHeadingElement where
-  toJSVal = return . unHTMLHeadingElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal HTMLHeadingElement where
-  fromJSVal = return . fmap HTMLHeadingElement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsHTMLElement HTMLHeadingElement
-instance IsElement HTMLHeadingElement
-instance IsNode HTMLHeadingElement
-instance IsEventTarget HTMLHeadingElement
-instance IsGObject HTMLHeadingElement where
-  toGObject = GObject . unHTMLHeadingElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = HTMLHeadingElement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToHTMLHeadingElement :: IsGObject obj => obj -> IO HTMLHeadingElement
-castToHTMLHeadingElement = castTo gTypeHTMLHeadingElement "HTMLHeadingElement"
-
-foreign import javascript unsafe "window[\"HTMLHeadingElement\"]" gTypeHTMLHeadingElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.HTMLHtmlElement".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.HTMLElement"
---     * "GHCJS.DOM.Element"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/HTMLHtmlElement Mozilla HTMLHtmlElement documentation>
-newtype HTMLHtmlElement = HTMLHtmlElement { unHTMLHtmlElement :: JSVal }
-
-instance Eq (HTMLHtmlElement) where
-  (HTMLHtmlElement a) == (HTMLHtmlElement b) = js_eq a b
-
-instance PToJSVal HTMLHtmlElement where
-  pToJSVal = unHTMLHtmlElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal HTMLHtmlElement where
-  pFromJSVal = HTMLHtmlElement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal HTMLHtmlElement where
-  toJSVal = return . unHTMLHtmlElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal HTMLHtmlElement where
-  fromJSVal = return . fmap HTMLHtmlElement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsHTMLElement HTMLHtmlElement
-instance IsElement HTMLHtmlElement
-instance IsNode HTMLHtmlElement
-instance IsEventTarget HTMLHtmlElement
-instance IsGObject HTMLHtmlElement where
-  toGObject = GObject . unHTMLHtmlElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = HTMLHtmlElement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToHTMLHtmlElement :: IsGObject obj => obj -> IO HTMLHtmlElement
-castToHTMLHtmlElement = castTo gTypeHTMLHtmlElement "HTMLHtmlElement"
-
-foreign import javascript unsafe "window[\"HTMLHtmlElement\"]" gTypeHTMLHtmlElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.HTMLIFrameElement".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.HTMLElement"
---     * "GHCJS.DOM.Element"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/HTMLIFrameElement Mozilla HTMLIFrameElement documentation>
-newtype HTMLIFrameElement = HTMLIFrameElement { unHTMLIFrameElement :: JSVal }
-
-instance Eq (HTMLIFrameElement) where
-  (HTMLIFrameElement a) == (HTMLIFrameElement b) = js_eq a b
-
-instance PToJSVal HTMLIFrameElement where
-  pToJSVal = unHTMLIFrameElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal HTMLIFrameElement where
-  pFromJSVal = HTMLIFrameElement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal HTMLIFrameElement where
-  toJSVal = return . unHTMLIFrameElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal HTMLIFrameElement where
-  fromJSVal = return . fmap HTMLIFrameElement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsHTMLElement HTMLIFrameElement
-instance IsElement HTMLIFrameElement
-instance IsNode HTMLIFrameElement
-instance IsEventTarget HTMLIFrameElement
-instance IsGObject HTMLIFrameElement where
-  toGObject = GObject . unHTMLIFrameElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = HTMLIFrameElement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToHTMLIFrameElement :: IsGObject obj => obj -> IO HTMLIFrameElement
-castToHTMLIFrameElement = castTo gTypeHTMLIFrameElement "HTMLIFrameElement"
-
-foreign import javascript unsafe "window[\"HTMLIFrameElement\"]" gTypeHTMLIFrameElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.HTMLImageElement".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.HTMLElement"
---     * "GHCJS.DOM.Element"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/HTMLImageElement Mozilla HTMLImageElement documentation>
-newtype HTMLImageElement = HTMLImageElement { unHTMLImageElement :: JSVal }
-
-instance Eq (HTMLImageElement) where
-  (HTMLImageElement a) == (HTMLImageElement b) = js_eq a b
-
-instance PToJSVal HTMLImageElement where
-  pToJSVal = unHTMLImageElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal HTMLImageElement where
-  pFromJSVal = HTMLImageElement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal HTMLImageElement where
-  toJSVal = return . unHTMLImageElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal HTMLImageElement where
-  fromJSVal = return . fmap HTMLImageElement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsHTMLElement HTMLImageElement
-instance IsElement HTMLImageElement
-instance IsNode HTMLImageElement
-instance IsEventTarget HTMLImageElement
-instance IsGObject HTMLImageElement where
-  toGObject = GObject . unHTMLImageElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = HTMLImageElement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToHTMLImageElement :: IsGObject obj => obj -> IO HTMLImageElement
-castToHTMLImageElement = castTo gTypeHTMLImageElement "HTMLImageElement"
-
-foreign import javascript unsafe "window[\"HTMLImageElement\"]" gTypeHTMLImageElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.HTMLInputElement".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.HTMLElement"
---     * "GHCJS.DOM.Element"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/HTMLInputElement Mozilla HTMLInputElement documentation>
-newtype HTMLInputElement = HTMLInputElement { unHTMLInputElement :: JSVal }
-
-instance Eq (HTMLInputElement) where
-  (HTMLInputElement a) == (HTMLInputElement b) = js_eq a b
-
-instance PToJSVal HTMLInputElement where
-  pToJSVal = unHTMLInputElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal HTMLInputElement where
-  pFromJSVal = HTMLInputElement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal HTMLInputElement where
-  toJSVal = return . unHTMLInputElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal HTMLInputElement where
-  fromJSVal = return . fmap HTMLInputElement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsHTMLElement HTMLInputElement
-instance IsElement HTMLInputElement
-instance IsNode HTMLInputElement
-instance IsEventTarget HTMLInputElement
-instance IsGObject HTMLInputElement where
-  toGObject = GObject . unHTMLInputElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = HTMLInputElement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToHTMLInputElement :: IsGObject obj => obj -> IO HTMLInputElement
-castToHTMLInputElement = castTo gTypeHTMLInputElement "HTMLInputElement"
-
-foreign import javascript unsafe "window[\"HTMLInputElement\"]" gTypeHTMLInputElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.HTMLKeygenElement".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.HTMLElement"
---     * "GHCJS.DOM.Element"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/HTMLKeygenElement Mozilla HTMLKeygenElement documentation>
-newtype HTMLKeygenElement = HTMLKeygenElement { unHTMLKeygenElement :: JSVal }
-
-instance Eq (HTMLKeygenElement) where
-  (HTMLKeygenElement a) == (HTMLKeygenElement b) = js_eq a b
-
-instance PToJSVal HTMLKeygenElement where
-  pToJSVal = unHTMLKeygenElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal HTMLKeygenElement where
-  pFromJSVal = HTMLKeygenElement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal HTMLKeygenElement where
-  toJSVal = return . unHTMLKeygenElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal HTMLKeygenElement where
-  fromJSVal = return . fmap HTMLKeygenElement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsHTMLElement HTMLKeygenElement
-instance IsElement HTMLKeygenElement
-instance IsNode HTMLKeygenElement
-instance IsEventTarget HTMLKeygenElement
-instance IsGObject HTMLKeygenElement where
-  toGObject = GObject . unHTMLKeygenElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = HTMLKeygenElement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToHTMLKeygenElement :: IsGObject obj => obj -> IO HTMLKeygenElement
-castToHTMLKeygenElement = castTo gTypeHTMLKeygenElement "HTMLKeygenElement"
-
-foreign import javascript unsafe "window[\"HTMLKeygenElement\"]" gTypeHTMLKeygenElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.HTMLLIElement".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.HTMLElement"
---     * "GHCJS.DOM.Element"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/HTMLLIElement Mozilla HTMLLIElement documentation>
-newtype HTMLLIElement = HTMLLIElement { unHTMLLIElement :: JSVal }
-
-instance Eq (HTMLLIElement) where
-  (HTMLLIElement a) == (HTMLLIElement b) = js_eq a b
-
-instance PToJSVal HTMLLIElement where
-  pToJSVal = unHTMLLIElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal HTMLLIElement where
-  pFromJSVal = HTMLLIElement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal HTMLLIElement where
-  toJSVal = return . unHTMLLIElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal HTMLLIElement where
-  fromJSVal = return . fmap HTMLLIElement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsHTMLElement HTMLLIElement
-instance IsElement HTMLLIElement
-instance IsNode HTMLLIElement
-instance IsEventTarget HTMLLIElement
-instance IsGObject HTMLLIElement where
-  toGObject = GObject . unHTMLLIElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = HTMLLIElement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToHTMLLIElement :: IsGObject obj => obj -> IO HTMLLIElement
-castToHTMLLIElement = castTo gTypeHTMLLIElement "HTMLLIElement"
-
-foreign import javascript unsafe "window[\"HTMLLIElement\"]" gTypeHTMLLIElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.HTMLLabelElement".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.HTMLElement"
---     * "GHCJS.DOM.Element"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/HTMLLabelElement Mozilla HTMLLabelElement documentation>
-newtype HTMLLabelElement = HTMLLabelElement { unHTMLLabelElement :: JSVal }
-
-instance Eq (HTMLLabelElement) where
-  (HTMLLabelElement a) == (HTMLLabelElement b) = js_eq a b
-
-instance PToJSVal HTMLLabelElement where
-  pToJSVal = unHTMLLabelElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal HTMLLabelElement where
-  pFromJSVal = HTMLLabelElement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal HTMLLabelElement where
-  toJSVal = return . unHTMLLabelElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal HTMLLabelElement where
-  fromJSVal = return . fmap HTMLLabelElement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsHTMLElement HTMLLabelElement
-instance IsElement HTMLLabelElement
-instance IsNode HTMLLabelElement
-instance IsEventTarget HTMLLabelElement
-instance IsGObject HTMLLabelElement where
-  toGObject = GObject . unHTMLLabelElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = HTMLLabelElement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToHTMLLabelElement :: IsGObject obj => obj -> IO HTMLLabelElement
-castToHTMLLabelElement = castTo gTypeHTMLLabelElement "HTMLLabelElement"
-
-foreign import javascript unsafe "window[\"HTMLLabelElement\"]" gTypeHTMLLabelElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.HTMLLegendElement".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.HTMLElement"
---     * "GHCJS.DOM.Element"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/HTMLLegendElement Mozilla HTMLLegendElement documentation>
-newtype HTMLLegendElement = HTMLLegendElement { unHTMLLegendElement :: JSVal }
-
-instance Eq (HTMLLegendElement) where
-  (HTMLLegendElement a) == (HTMLLegendElement b) = js_eq a b
-
-instance PToJSVal HTMLLegendElement where
-  pToJSVal = unHTMLLegendElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal HTMLLegendElement where
-  pFromJSVal = HTMLLegendElement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal HTMLLegendElement where
-  toJSVal = return . unHTMLLegendElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal HTMLLegendElement where
-  fromJSVal = return . fmap HTMLLegendElement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsHTMLElement HTMLLegendElement
-instance IsElement HTMLLegendElement
-instance IsNode HTMLLegendElement
-instance IsEventTarget HTMLLegendElement
-instance IsGObject HTMLLegendElement where
-  toGObject = GObject . unHTMLLegendElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = HTMLLegendElement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToHTMLLegendElement :: IsGObject obj => obj -> IO HTMLLegendElement
-castToHTMLLegendElement = castTo gTypeHTMLLegendElement "HTMLLegendElement"
-
-foreign import javascript unsafe "window[\"HTMLLegendElement\"]" gTypeHTMLLegendElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.HTMLLinkElement".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.HTMLElement"
---     * "GHCJS.DOM.Element"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/HTMLLinkElement Mozilla HTMLLinkElement documentation>
-newtype HTMLLinkElement = HTMLLinkElement { unHTMLLinkElement :: JSVal }
-
-instance Eq (HTMLLinkElement) where
-  (HTMLLinkElement a) == (HTMLLinkElement b) = js_eq a b
-
-instance PToJSVal HTMLLinkElement where
-  pToJSVal = unHTMLLinkElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal HTMLLinkElement where
-  pFromJSVal = HTMLLinkElement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal HTMLLinkElement where
-  toJSVal = return . unHTMLLinkElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal HTMLLinkElement where
-  fromJSVal = return . fmap HTMLLinkElement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsHTMLElement HTMLLinkElement
-instance IsElement HTMLLinkElement
-instance IsNode HTMLLinkElement
-instance IsEventTarget HTMLLinkElement
-instance IsGObject HTMLLinkElement where
-  toGObject = GObject . unHTMLLinkElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = HTMLLinkElement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToHTMLLinkElement :: IsGObject obj => obj -> IO HTMLLinkElement
-castToHTMLLinkElement = castTo gTypeHTMLLinkElement "HTMLLinkElement"
-
-foreign import javascript unsafe "window[\"HTMLLinkElement\"]" gTypeHTMLLinkElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.HTMLMapElement".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.HTMLElement"
---     * "GHCJS.DOM.Element"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/HTMLMapElement Mozilla HTMLMapElement documentation>
-newtype HTMLMapElement = HTMLMapElement { unHTMLMapElement :: JSVal }
-
-instance Eq (HTMLMapElement) where
-  (HTMLMapElement a) == (HTMLMapElement b) = js_eq a b
-
-instance PToJSVal HTMLMapElement where
-  pToJSVal = unHTMLMapElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal HTMLMapElement where
-  pFromJSVal = HTMLMapElement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal HTMLMapElement where
-  toJSVal = return . unHTMLMapElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal HTMLMapElement where
-  fromJSVal = return . fmap HTMLMapElement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsHTMLElement HTMLMapElement
-instance IsElement HTMLMapElement
-instance IsNode HTMLMapElement
-instance IsEventTarget HTMLMapElement
-instance IsGObject HTMLMapElement where
-  toGObject = GObject . unHTMLMapElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = HTMLMapElement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToHTMLMapElement :: IsGObject obj => obj -> IO HTMLMapElement
-castToHTMLMapElement = castTo gTypeHTMLMapElement "HTMLMapElement"
-
-foreign import javascript unsafe "window[\"HTMLMapElement\"]" gTypeHTMLMapElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.HTMLMarqueeElement".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.HTMLElement"
---     * "GHCJS.DOM.Element"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/HTMLMarqueeElement Mozilla HTMLMarqueeElement documentation>
-newtype HTMLMarqueeElement = HTMLMarqueeElement { unHTMLMarqueeElement :: JSVal }
-
-instance Eq (HTMLMarqueeElement) where
-  (HTMLMarqueeElement a) == (HTMLMarqueeElement b) = js_eq a b
-
-instance PToJSVal HTMLMarqueeElement where
-  pToJSVal = unHTMLMarqueeElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal HTMLMarqueeElement where
-  pFromJSVal = HTMLMarqueeElement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal HTMLMarqueeElement where
-  toJSVal = return . unHTMLMarqueeElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal HTMLMarqueeElement where
-  fromJSVal = return . fmap HTMLMarqueeElement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsHTMLElement HTMLMarqueeElement
-instance IsElement HTMLMarqueeElement
-instance IsNode HTMLMarqueeElement
-instance IsEventTarget HTMLMarqueeElement
-instance IsGObject HTMLMarqueeElement where
-  toGObject = GObject . unHTMLMarqueeElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = HTMLMarqueeElement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToHTMLMarqueeElement :: IsGObject obj => obj -> IO HTMLMarqueeElement
-castToHTMLMarqueeElement = castTo gTypeHTMLMarqueeElement "HTMLMarqueeElement"
-
-foreign import javascript unsafe "window[\"HTMLMarqueeElement\"]" gTypeHTMLMarqueeElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.HTMLMediaElement".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.HTMLElement"
---     * "GHCJS.DOM.Element"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/HTMLMediaElement Mozilla HTMLMediaElement documentation>
-newtype HTMLMediaElement = HTMLMediaElement { unHTMLMediaElement :: JSVal }
-
-instance Eq (HTMLMediaElement) where
-  (HTMLMediaElement a) == (HTMLMediaElement b) = js_eq a b
-
-instance PToJSVal HTMLMediaElement where
-  pToJSVal = unHTMLMediaElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal HTMLMediaElement where
-  pFromJSVal = HTMLMediaElement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal HTMLMediaElement where
-  toJSVal = return . unHTMLMediaElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal HTMLMediaElement where
-  fromJSVal = return . fmap HTMLMediaElement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-class IsHTMLElement o => IsHTMLMediaElement o
-toHTMLMediaElement :: IsHTMLMediaElement o => o -> HTMLMediaElement
-toHTMLMediaElement = unsafeCastGObject . toGObject
-
-instance IsHTMLMediaElement HTMLMediaElement
-instance IsHTMLElement HTMLMediaElement
-instance IsElement HTMLMediaElement
-instance IsNode HTMLMediaElement
-instance IsEventTarget HTMLMediaElement
-instance IsGObject HTMLMediaElement where
-  toGObject = GObject . unHTMLMediaElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = HTMLMediaElement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToHTMLMediaElement :: IsGObject obj => obj -> IO HTMLMediaElement
-castToHTMLMediaElement = castTo gTypeHTMLMediaElement "HTMLMediaElement"
-
-foreign import javascript unsafe "window[\"HTMLMediaElement\"]" gTypeHTMLMediaElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.HTMLMenuElement".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.HTMLElement"
---     * "GHCJS.DOM.Element"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/HTMLMenuElement Mozilla HTMLMenuElement documentation>
-newtype HTMLMenuElement = HTMLMenuElement { unHTMLMenuElement :: JSVal }
-
-instance Eq (HTMLMenuElement) where
-  (HTMLMenuElement a) == (HTMLMenuElement b) = js_eq a b
-
-instance PToJSVal HTMLMenuElement where
-  pToJSVal = unHTMLMenuElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal HTMLMenuElement where
-  pFromJSVal = HTMLMenuElement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal HTMLMenuElement where
-  toJSVal = return . unHTMLMenuElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal HTMLMenuElement where
-  fromJSVal = return . fmap HTMLMenuElement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsHTMLElement HTMLMenuElement
-instance IsElement HTMLMenuElement
-instance IsNode HTMLMenuElement
-instance IsEventTarget HTMLMenuElement
-instance IsGObject HTMLMenuElement where
-  toGObject = GObject . unHTMLMenuElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = HTMLMenuElement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToHTMLMenuElement :: IsGObject obj => obj -> IO HTMLMenuElement
-castToHTMLMenuElement = castTo gTypeHTMLMenuElement "HTMLMenuElement"
-
-foreign import javascript unsafe "window[\"HTMLMenuElement\"]" gTypeHTMLMenuElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.HTMLMetaElement".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.HTMLElement"
---     * "GHCJS.DOM.Element"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/HTMLMetaElement Mozilla HTMLMetaElement documentation>
-newtype HTMLMetaElement = HTMLMetaElement { unHTMLMetaElement :: JSVal }
-
-instance Eq (HTMLMetaElement) where
-  (HTMLMetaElement a) == (HTMLMetaElement b) = js_eq a b
-
-instance PToJSVal HTMLMetaElement where
-  pToJSVal = unHTMLMetaElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal HTMLMetaElement where
-  pFromJSVal = HTMLMetaElement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal HTMLMetaElement where
-  toJSVal = return . unHTMLMetaElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal HTMLMetaElement where
-  fromJSVal = return . fmap HTMLMetaElement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsHTMLElement HTMLMetaElement
-instance IsElement HTMLMetaElement
-instance IsNode HTMLMetaElement
-instance IsEventTarget HTMLMetaElement
-instance IsGObject HTMLMetaElement where
-  toGObject = GObject . unHTMLMetaElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = HTMLMetaElement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToHTMLMetaElement :: IsGObject obj => obj -> IO HTMLMetaElement
-castToHTMLMetaElement = castTo gTypeHTMLMetaElement "HTMLMetaElement"
-
-foreign import javascript unsafe "window[\"HTMLMetaElement\"]" gTypeHTMLMetaElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.HTMLMeterElement".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.HTMLElement"
---     * "GHCJS.DOM.Element"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/HTMLMeterElement Mozilla HTMLMeterElement documentation>
-newtype HTMLMeterElement = HTMLMeterElement { unHTMLMeterElement :: JSVal }
-
-instance Eq (HTMLMeterElement) where
-  (HTMLMeterElement a) == (HTMLMeterElement b) = js_eq a b
-
-instance PToJSVal HTMLMeterElement where
-  pToJSVal = unHTMLMeterElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal HTMLMeterElement where
-  pFromJSVal = HTMLMeterElement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal HTMLMeterElement where
-  toJSVal = return . unHTMLMeterElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal HTMLMeterElement where
-  fromJSVal = return . fmap HTMLMeterElement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsHTMLElement HTMLMeterElement
-instance IsElement HTMLMeterElement
-instance IsNode HTMLMeterElement
-instance IsEventTarget HTMLMeterElement
-instance IsGObject HTMLMeterElement where
-  toGObject = GObject . unHTMLMeterElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = HTMLMeterElement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToHTMLMeterElement :: IsGObject obj => obj -> IO HTMLMeterElement
-castToHTMLMeterElement = castTo gTypeHTMLMeterElement "HTMLMeterElement"
-
-foreign import javascript unsafe "window[\"HTMLMeterElement\"]" gTypeHTMLMeterElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.HTMLModElement".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.HTMLElement"
---     * "GHCJS.DOM.Element"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/HTMLModElement Mozilla HTMLModElement documentation>
-newtype HTMLModElement = HTMLModElement { unHTMLModElement :: JSVal }
-
-instance Eq (HTMLModElement) where
-  (HTMLModElement a) == (HTMLModElement b) = js_eq a b
-
-instance PToJSVal HTMLModElement where
-  pToJSVal = unHTMLModElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal HTMLModElement where
-  pFromJSVal = HTMLModElement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal HTMLModElement where
-  toJSVal = return . unHTMLModElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal HTMLModElement where
-  fromJSVal = return . fmap HTMLModElement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsHTMLElement HTMLModElement
-instance IsElement HTMLModElement
-instance IsNode HTMLModElement
-instance IsEventTarget HTMLModElement
-instance IsGObject HTMLModElement where
-  toGObject = GObject . unHTMLModElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = HTMLModElement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToHTMLModElement :: IsGObject obj => obj -> IO HTMLModElement
-castToHTMLModElement = castTo gTypeHTMLModElement "HTMLModElement"
-
-foreign import javascript unsafe "window[\"HTMLModElement\"]" gTypeHTMLModElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.HTMLOListElement".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.HTMLElement"
---     * "GHCJS.DOM.Element"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/HTMLOListElement Mozilla HTMLOListElement documentation>
-newtype HTMLOListElement = HTMLOListElement { unHTMLOListElement :: JSVal }
-
-instance Eq (HTMLOListElement) where
-  (HTMLOListElement a) == (HTMLOListElement b) = js_eq a b
-
-instance PToJSVal HTMLOListElement where
-  pToJSVal = unHTMLOListElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal HTMLOListElement where
-  pFromJSVal = HTMLOListElement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal HTMLOListElement where
-  toJSVal = return . unHTMLOListElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal HTMLOListElement where
-  fromJSVal = return . fmap HTMLOListElement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsHTMLElement HTMLOListElement
-instance IsElement HTMLOListElement
-instance IsNode HTMLOListElement
-instance IsEventTarget HTMLOListElement
-instance IsGObject HTMLOListElement where
-  toGObject = GObject . unHTMLOListElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = HTMLOListElement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToHTMLOListElement :: IsGObject obj => obj -> IO HTMLOListElement
-castToHTMLOListElement = castTo gTypeHTMLOListElement "HTMLOListElement"
-
-foreign import javascript unsafe "window[\"HTMLOListElement\"]" gTypeHTMLOListElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.HTMLObjectElement".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.HTMLElement"
---     * "GHCJS.DOM.Element"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/HTMLObjectElement Mozilla HTMLObjectElement documentation>
-newtype HTMLObjectElement = HTMLObjectElement { unHTMLObjectElement :: JSVal }
-
-instance Eq (HTMLObjectElement) where
-  (HTMLObjectElement a) == (HTMLObjectElement b) = js_eq a b
-
-instance PToJSVal HTMLObjectElement where
-  pToJSVal = unHTMLObjectElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal HTMLObjectElement where
-  pFromJSVal = HTMLObjectElement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal HTMLObjectElement where
-  toJSVal = return . unHTMLObjectElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal HTMLObjectElement where
-  fromJSVal = return . fmap HTMLObjectElement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsHTMLElement HTMLObjectElement
-instance IsElement HTMLObjectElement
-instance IsNode HTMLObjectElement
-instance IsEventTarget HTMLObjectElement
-instance IsGObject HTMLObjectElement where
-  toGObject = GObject . unHTMLObjectElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = HTMLObjectElement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToHTMLObjectElement :: IsGObject obj => obj -> IO HTMLObjectElement
-castToHTMLObjectElement = castTo gTypeHTMLObjectElement "HTMLObjectElement"
-
-foreign import javascript unsafe "window[\"HTMLObjectElement\"]" gTypeHTMLObjectElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.HTMLOptGroupElement".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.HTMLElement"
---     * "GHCJS.DOM.Element"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/HTMLOptGroupElement Mozilla HTMLOptGroupElement documentation>
-newtype HTMLOptGroupElement = HTMLOptGroupElement { unHTMLOptGroupElement :: JSVal }
-
-instance Eq (HTMLOptGroupElement) where
-  (HTMLOptGroupElement a) == (HTMLOptGroupElement b) = js_eq a b
-
-instance PToJSVal HTMLOptGroupElement where
-  pToJSVal = unHTMLOptGroupElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal HTMLOptGroupElement where
-  pFromJSVal = HTMLOptGroupElement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal HTMLOptGroupElement where
-  toJSVal = return . unHTMLOptGroupElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal HTMLOptGroupElement where
-  fromJSVal = return . fmap HTMLOptGroupElement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsHTMLElement HTMLOptGroupElement
-instance IsElement HTMLOptGroupElement
-instance IsNode HTMLOptGroupElement
-instance IsEventTarget HTMLOptGroupElement
-instance IsGObject HTMLOptGroupElement where
-  toGObject = GObject . unHTMLOptGroupElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = HTMLOptGroupElement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToHTMLOptGroupElement :: IsGObject obj => obj -> IO HTMLOptGroupElement
-castToHTMLOptGroupElement = castTo gTypeHTMLOptGroupElement "HTMLOptGroupElement"
-
-foreign import javascript unsafe "window[\"HTMLOptGroupElement\"]" gTypeHTMLOptGroupElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.HTMLOptionElement".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.HTMLElement"
---     * "GHCJS.DOM.Element"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/HTMLOptionElement Mozilla HTMLOptionElement documentation>
-newtype HTMLOptionElement = HTMLOptionElement { unHTMLOptionElement :: JSVal }
-
-instance Eq (HTMLOptionElement) where
-  (HTMLOptionElement a) == (HTMLOptionElement b) = js_eq a b
-
-instance PToJSVal HTMLOptionElement where
-  pToJSVal = unHTMLOptionElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal HTMLOptionElement where
-  pFromJSVal = HTMLOptionElement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal HTMLOptionElement where
-  toJSVal = return . unHTMLOptionElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal HTMLOptionElement where
-  fromJSVal = return . fmap HTMLOptionElement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsHTMLElement HTMLOptionElement
-instance IsElement HTMLOptionElement
-instance IsNode HTMLOptionElement
-instance IsEventTarget HTMLOptionElement
-instance IsGObject HTMLOptionElement where
-  toGObject = GObject . unHTMLOptionElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = HTMLOptionElement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToHTMLOptionElement :: IsGObject obj => obj -> IO HTMLOptionElement
-castToHTMLOptionElement = castTo gTypeHTMLOptionElement "HTMLOptionElement"
-
-foreign import javascript unsafe "window[\"HTMLOptionElement\"]" gTypeHTMLOptionElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.HTMLOptionsCollection".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.HTMLCollection"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/HTMLOptionsCollection Mozilla HTMLOptionsCollection documentation>
-newtype HTMLOptionsCollection = HTMLOptionsCollection { unHTMLOptionsCollection :: JSVal }
-
-instance Eq (HTMLOptionsCollection) where
-  (HTMLOptionsCollection a) == (HTMLOptionsCollection b) = js_eq a b
-
-instance PToJSVal HTMLOptionsCollection where
-  pToJSVal = unHTMLOptionsCollection
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal HTMLOptionsCollection where
-  pFromJSVal = HTMLOptionsCollection
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal HTMLOptionsCollection where
-  toJSVal = return . unHTMLOptionsCollection
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal HTMLOptionsCollection where
-  fromJSVal = return . fmap HTMLOptionsCollection . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsHTMLCollection HTMLOptionsCollection
-instance IsGObject HTMLOptionsCollection where
-  toGObject = GObject . unHTMLOptionsCollection
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = HTMLOptionsCollection . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToHTMLOptionsCollection :: IsGObject obj => obj -> IO HTMLOptionsCollection
-castToHTMLOptionsCollection = castTo gTypeHTMLOptionsCollection "HTMLOptionsCollection"
-
-foreign import javascript unsafe "window[\"HTMLOptionsCollection\"]" gTypeHTMLOptionsCollection :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.HTMLOutputElement".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.HTMLElement"
---     * "GHCJS.DOM.Element"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/HTMLOutputElement Mozilla HTMLOutputElement documentation>
-newtype HTMLOutputElement = HTMLOutputElement { unHTMLOutputElement :: JSVal }
-
-instance Eq (HTMLOutputElement) where
-  (HTMLOutputElement a) == (HTMLOutputElement b) = js_eq a b
-
-instance PToJSVal HTMLOutputElement where
-  pToJSVal = unHTMLOutputElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal HTMLOutputElement where
-  pFromJSVal = HTMLOutputElement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal HTMLOutputElement where
-  toJSVal = return . unHTMLOutputElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal HTMLOutputElement where
-  fromJSVal = return . fmap HTMLOutputElement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsHTMLElement HTMLOutputElement
-instance IsElement HTMLOutputElement
-instance IsNode HTMLOutputElement
-instance IsEventTarget HTMLOutputElement
-instance IsGObject HTMLOutputElement where
-  toGObject = GObject . unHTMLOutputElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = HTMLOutputElement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToHTMLOutputElement :: IsGObject obj => obj -> IO HTMLOutputElement
-castToHTMLOutputElement = castTo gTypeHTMLOutputElement "HTMLOutputElement"
-
-foreign import javascript unsafe "window[\"HTMLOutputElement\"]" gTypeHTMLOutputElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.HTMLParagraphElement".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.HTMLElement"
---     * "GHCJS.DOM.Element"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/HTMLParagraphElement Mozilla HTMLParagraphElement documentation>
-newtype HTMLParagraphElement = HTMLParagraphElement { unHTMLParagraphElement :: JSVal }
-
-instance Eq (HTMLParagraphElement) where
-  (HTMLParagraphElement a) == (HTMLParagraphElement b) = js_eq a b
-
-instance PToJSVal HTMLParagraphElement where
-  pToJSVal = unHTMLParagraphElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal HTMLParagraphElement where
-  pFromJSVal = HTMLParagraphElement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal HTMLParagraphElement where
-  toJSVal = return . unHTMLParagraphElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal HTMLParagraphElement where
-  fromJSVal = return . fmap HTMLParagraphElement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsHTMLElement HTMLParagraphElement
-instance IsElement HTMLParagraphElement
-instance IsNode HTMLParagraphElement
-instance IsEventTarget HTMLParagraphElement
-instance IsGObject HTMLParagraphElement where
-  toGObject = GObject . unHTMLParagraphElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = HTMLParagraphElement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToHTMLParagraphElement :: IsGObject obj => obj -> IO HTMLParagraphElement
-castToHTMLParagraphElement = castTo gTypeHTMLParagraphElement "HTMLParagraphElement"
-
-foreign import javascript unsafe "window[\"HTMLParagraphElement\"]" gTypeHTMLParagraphElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.HTMLParamElement".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.HTMLElement"
---     * "GHCJS.DOM.Element"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/HTMLParamElement Mozilla HTMLParamElement documentation>
-newtype HTMLParamElement = HTMLParamElement { unHTMLParamElement :: JSVal }
-
-instance Eq (HTMLParamElement) where
-  (HTMLParamElement a) == (HTMLParamElement b) = js_eq a b
-
-instance PToJSVal HTMLParamElement where
-  pToJSVal = unHTMLParamElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal HTMLParamElement where
-  pFromJSVal = HTMLParamElement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal HTMLParamElement where
-  toJSVal = return . unHTMLParamElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal HTMLParamElement where
-  fromJSVal = return . fmap HTMLParamElement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsHTMLElement HTMLParamElement
-instance IsElement HTMLParamElement
-instance IsNode HTMLParamElement
-instance IsEventTarget HTMLParamElement
-instance IsGObject HTMLParamElement where
-  toGObject = GObject . unHTMLParamElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = HTMLParamElement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToHTMLParamElement :: IsGObject obj => obj -> IO HTMLParamElement
-castToHTMLParamElement = castTo gTypeHTMLParamElement "HTMLParamElement"
-
-foreign import javascript unsafe "window[\"HTMLParamElement\"]" gTypeHTMLParamElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.HTMLPreElement".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.HTMLElement"
---     * "GHCJS.DOM.Element"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/HTMLPreElement Mozilla HTMLPreElement documentation>
-newtype HTMLPreElement = HTMLPreElement { unHTMLPreElement :: JSVal }
-
-instance Eq (HTMLPreElement) where
-  (HTMLPreElement a) == (HTMLPreElement b) = js_eq a b
-
-instance PToJSVal HTMLPreElement where
-  pToJSVal = unHTMLPreElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal HTMLPreElement where
-  pFromJSVal = HTMLPreElement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal HTMLPreElement where
-  toJSVal = return . unHTMLPreElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal HTMLPreElement where
-  fromJSVal = return . fmap HTMLPreElement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsHTMLElement HTMLPreElement
-instance IsElement HTMLPreElement
-instance IsNode HTMLPreElement
-instance IsEventTarget HTMLPreElement
-instance IsGObject HTMLPreElement where
-  toGObject = GObject . unHTMLPreElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = HTMLPreElement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToHTMLPreElement :: IsGObject obj => obj -> IO HTMLPreElement
-castToHTMLPreElement = castTo gTypeHTMLPreElement "HTMLPreElement"
-
-foreign import javascript unsafe "window[\"HTMLPreElement\"]" gTypeHTMLPreElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.HTMLProgressElement".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.HTMLElement"
---     * "GHCJS.DOM.Element"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/HTMLProgressElement Mozilla HTMLProgressElement documentation>
-newtype HTMLProgressElement = HTMLProgressElement { unHTMLProgressElement :: JSVal }
-
-instance Eq (HTMLProgressElement) where
-  (HTMLProgressElement a) == (HTMLProgressElement b) = js_eq a b
-
-instance PToJSVal HTMLProgressElement where
-  pToJSVal = unHTMLProgressElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal HTMLProgressElement where
-  pFromJSVal = HTMLProgressElement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal HTMLProgressElement where
-  toJSVal = return . unHTMLProgressElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal HTMLProgressElement where
-  fromJSVal = return . fmap HTMLProgressElement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsHTMLElement HTMLProgressElement
-instance IsElement HTMLProgressElement
-instance IsNode HTMLProgressElement
-instance IsEventTarget HTMLProgressElement
-instance IsGObject HTMLProgressElement where
-  toGObject = GObject . unHTMLProgressElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = HTMLProgressElement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToHTMLProgressElement :: IsGObject obj => obj -> IO HTMLProgressElement
-castToHTMLProgressElement = castTo gTypeHTMLProgressElement "HTMLProgressElement"
-
-foreign import javascript unsafe "window[\"HTMLProgressElement\"]" gTypeHTMLProgressElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.HTMLQuoteElement".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.HTMLElement"
---     * "GHCJS.DOM.Element"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/HTMLQuoteElement Mozilla HTMLQuoteElement documentation>
-newtype HTMLQuoteElement = HTMLQuoteElement { unHTMLQuoteElement :: JSVal }
-
-instance Eq (HTMLQuoteElement) where
-  (HTMLQuoteElement a) == (HTMLQuoteElement b) = js_eq a b
-
-instance PToJSVal HTMLQuoteElement where
-  pToJSVal = unHTMLQuoteElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal HTMLQuoteElement where
-  pFromJSVal = HTMLQuoteElement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal HTMLQuoteElement where
-  toJSVal = return . unHTMLQuoteElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal HTMLQuoteElement where
-  fromJSVal = return . fmap HTMLQuoteElement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsHTMLElement HTMLQuoteElement
-instance IsElement HTMLQuoteElement
-instance IsNode HTMLQuoteElement
-instance IsEventTarget HTMLQuoteElement
-instance IsGObject HTMLQuoteElement where
-  toGObject = GObject . unHTMLQuoteElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = HTMLQuoteElement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToHTMLQuoteElement :: IsGObject obj => obj -> IO HTMLQuoteElement
-castToHTMLQuoteElement = castTo gTypeHTMLQuoteElement "HTMLQuoteElement"
-
-foreign import javascript unsafe "window[\"HTMLQuoteElement\"]" gTypeHTMLQuoteElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.HTMLScriptElement".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.HTMLElement"
---     * "GHCJS.DOM.Element"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/HTMLScriptElement Mozilla HTMLScriptElement documentation>
-newtype HTMLScriptElement = HTMLScriptElement { unHTMLScriptElement :: JSVal }
-
-instance Eq (HTMLScriptElement) where
-  (HTMLScriptElement a) == (HTMLScriptElement b) = js_eq a b
-
-instance PToJSVal HTMLScriptElement where
-  pToJSVal = unHTMLScriptElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal HTMLScriptElement where
-  pFromJSVal = HTMLScriptElement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal HTMLScriptElement where
-  toJSVal = return . unHTMLScriptElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal HTMLScriptElement where
-  fromJSVal = return . fmap HTMLScriptElement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsHTMLElement HTMLScriptElement
-instance IsElement HTMLScriptElement
-instance IsNode HTMLScriptElement
-instance IsEventTarget HTMLScriptElement
-instance IsGObject HTMLScriptElement where
-  toGObject = GObject . unHTMLScriptElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = HTMLScriptElement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToHTMLScriptElement :: IsGObject obj => obj -> IO HTMLScriptElement
-castToHTMLScriptElement = castTo gTypeHTMLScriptElement "HTMLScriptElement"
-
-foreign import javascript unsafe "window[\"HTMLScriptElement\"]" gTypeHTMLScriptElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.HTMLSelectElement".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.HTMLElement"
---     * "GHCJS.DOM.Element"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/HTMLSelectElement Mozilla HTMLSelectElement documentation>
-newtype HTMLSelectElement = HTMLSelectElement { unHTMLSelectElement :: JSVal }
-
-instance Eq (HTMLSelectElement) where
-  (HTMLSelectElement a) == (HTMLSelectElement b) = js_eq a b
-
-instance PToJSVal HTMLSelectElement where
-  pToJSVal = unHTMLSelectElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal HTMLSelectElement where
-  pFromJSVal = HTMLSelectElement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal HTMLSelectElement where
-  toJSVal = return . unHTMLSelectElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal HTMLSelectElement where
-  fromJSVal = return . fmap HTMLSelectElement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsHTMLElement HTMLSelectElement
-instance IsElement HTMLSelectElement
-instance IsNode HTMLSelectElement
-instance IsEventTarget HTMLSelectElement
-instance IsGObject HTMLSelectElement where
-  toGObject = GObject . unHTMLSelectElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = HTMLSelectElement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToHTMLSelectElement :: IsGObject obj => obj -> IO HTMLSelectElement
-castToHTMLSelectElement = castTo gTypeHTMLSelectElement "HTMLSelectElement"
-
-foreign import javascript unsafe "window[\"HTMLSelectElement\"]" gTypeHTMLSelectElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.HTMLSourceElement".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.HTMLElement"
---     * "GHCJS.DOM.Element"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/HTMLSourceElement Mozilla HTMLSourceElement documentation>
-newtype HTMLSourceElement = HTMLSourceElement { unHTMLSourceElement :: JSVal }
-
-instance Eq (HTMLSourceElement) where
-  (HTMLSourceElement a) == (HTMLSourceElement b) = js_eq a b
-
-instance PToJSVal HTMLSourceElement where
-  pToJSVal = unHTMLSourceElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal HTMLSourceElement where
-  pFromJSVal = HTMLSourceElement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal HTMLSourceElement where
-  toJSVal = return . unHTMLSourceElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal HTMLSourceElement where
-  fromJSVal = return . fmap HTMLSourceElement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsHTMLElement HTMLSourceElement
-instance IsElement HTMLSourceElement
-instance IsNode HTMLSourceElement
-instance IsEventTarget HTMLSourceElement
-instance IsGObject HTMLSourceElement where
-  toGObject = GObject . unHTMLSourceElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = HTMLSourceElement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToHTMLSourceElement :: IsGObject obj => obj -> IO HTMLSourceElement
-castToHTMLSourceElement = castTo gTypeHTMLSourceElement "HTMLSourceElement"
-
-foreign import javascript unsafe "window[\"HTMLSourceElement\"]" gTypeHTMLSourceElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.HTMLSpanElement".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.HTMLElement"
---     * "GHCJS.DOM.Element"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/HTMLSpanElement Mozilla HTMLSpanElement documentation>
-newtype HTMLSpanElement = HTMLSpanElement { unHTMLSpanElement :: JSVal }
-
-instance Eq (HTMLSpanElement) where
-  (HTMLSpanElement a) == (HTMLSpanElement b) = js_eq a b
-
-instance PToJSVal HTMLSpanElement where
-  pToJSVal = unHTMLSpanElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal HTMLSpanElement where
-  pFromJSVal = HTMLSpanElement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal HTMLSpanElement where
-  toJSVal = return . unHTMLSpanElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal HTMLSpanElement where
-  fromJSVal = return . fmap HTMLSpanElement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsHTMLElement HTMLSpanElement
-instance IsElement HTMLSpanElement
-instance IsNode HTMLSpanElement
-instance IsEventTarget HTMLSpanElement
-instance IsGObject HTMLSpanElement where
-  toGObject = GObject . unHTMLSpanElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = HTMLSpanElement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToHTMLSpanElement :: IsGObject obj => obj -> IO HTMLSpanElement
-castToHTMLSpanElement = castTo gTypeHTMLSpanElement "HTMLSpanElement"
-
-foreign import javascript unsafe "window[\"HTMLSpanElement\"]" gTypeHTMLSpanElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.HTMLStyleElement".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.HTMLElement"
---     * "GHCJS.DOM.Element"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/HTMLStyleElement Mozilla HTMLStyleElement documentation>
-newtype HTMLStyleElement = HTMLStyleElement { unHTMLStyleElement :: JSVal }
-
-instance Eq (HTMLStyleElement) where
-  (HTMLStyleElement a) == (HTMLStyleElement b) = js_eq a b
-
-instance PToJSVal HTMLStyleElement where
-  pToJSVal = unHTMLStyleElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal HTMLStyleElement where
-  pFromJSVal = HTMLStyleElement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal HTMLStyleElement where
-  toJSVal = return . unHTMLStyleElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal HTMLStyleElement where
-  fromJSVal = return . fmap HTMLStyleElement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsHTMLElement HTMLStyleElement
-instance IsElement HTMLStyleElement
-instance IsNode HTMLStyleElement
-instance IsEventTarget HTMLStyleElement
-instance IsGObject HTMLStyleElement where
-  toGObject = GObject . unHTMLStyleElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = HTMLStyleElement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToHTMLStyleElement :: IsGObject obj => obj -> IO HTMLStyleElement
-castToHTMLStyleElement = castTo gTypeHTMLStyleElement "HTMLStyleElement"
-
-foreign import javascript unsafe "window[\"HTMLStyleElement\"]" gTypeHTMLStyleElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.HTMLTableCaptionElement".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.HTMLElement"
---     * "GHCJS.DOM.Element"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/HTMLTableCaptionElement Mozilla HTMLTableCaptionElement documentation>
-newtype HTMLTableCaptionElement = HTMLTableCaptionElement { unHTMLTableCaptionElement :: JSVal }
-
-instance Eq (HTMLTableCaptionElement) where
-  (HTMLTableCaptionElement a) == (HTMLTableCaptionElement b) = js_eq a b
-
-instance PToJSVal HTMLTableCaptionElement where
-  pToJSVal = unHTMLTableCaptionElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal HTMLTableCaptionElement where
-  pFromJSVal = HTMLTableCaptionElement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal HTMLTableCaptionElement where
-  toJSVal = return . unHTMLTableCaptionElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal HTMLTableCaptionElement where
-  fromJSVal = return . fmap HTMLTableCaptionElement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsHTMLElement HTMLTableCaptionElement
-instance IsElement HTMLTableCaptionElement
-instance IsNode HTMLTableCaptionElement
-instance IsEventTarget HTMLTableCaptionElement
-instance IsGObject HTMLTableCaptionElement where
-  toGObject = GObject . unHTMLTableCaptionElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = HTMLTableCaptionElement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToHTMLTableCaptionElement :: IsGObject obj => obj -> IO HTMLTableCaptionElement
-castToHTMLTableCaptionElement = castTo gTypeHTMLTableCaptionElement "HTMLTableCaptionElement"
-
-foreign import javascript unsafe "window[\"HTMLTableCaptionElement\"]" gTypeHTMLTableCaptionElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.HTMLTableCellElement".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.HTMLElement"
---     * "GHCJS.DOM.Element"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/HTMLTableCellElement Mozilla HTMLTableCellElement documentation>
-newtype HTMLTableCellElement = HTMLTableCellElement { unHTMLTableCellElement :: JSVal }
-
-instance Eq (HTMLTableCellElement) where
-  (HTMLTableCellElement a) == (HTMLTableCellElement b) = js_eq a b
-
-instance PToJSVal HTMLTableCellElement where
-  pToJSVal = unHTMLTableCellElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal HTMLTableCellElement where
-  pFromJSVal = HTMLTableCellElement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal HTMLTableCellElement where
-  toJSVal = return . unHTMLTableCellElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal HTMLTableCellElement where
-  fromJSVal = return . fmap HTMLTableCellElement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsHTMLElement HTMLTableCellElement
-instance IsElement HTMLTableCellElement
-instance IsNode HTMLTableCellElement
-instance IsEventTarget HTMLTableCellElement
-instance IsGObject HTMLTableCellElement where
-  toGObject = GObject . unHTMLTableCellElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = HTMLTableCellElement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToHTMLTableCellElement :: IsGObject obj => obj -> IO HTMLTableCellElement
-castToHTMLTableCellElement = castTo gTypeHTMLTableCellElement "HTMLTableCellElement"
-
-foreign import javascript unsafe "window[\"HTMLTableCellElement\"]" gTypeHTMLTableCellElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.HTMLTableColElement".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.HTMLElement"
---     * "GHCJS.DOM.Element"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/HTMLTableColElement Mozilla HTMLTableColElement documentation>
-newtype HTMLTableColElement = HTMLTableColElement { unHTMLTableColElement :: JSVal }
-
-instance Eq (HTMLTableColElement) where
-  (HTMLTableColElement a) == (HTMLTableColElement b) = js_eq a b
-
-instance PToJSVal HTMLTableColElement where
-  pToJSVal = unHTMLTableColElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal HTMLTableColElement where
-  pFromJSVal = HTMLTableColElement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal HTMLTableColElement where
-  toJSVal = return . unHTMLTableColElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal HTMLTableColElement where
-  fromJSVal = return . fmap HTMLTableColElement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsHTMLElement HTMLTableColElement
-instance IsElement HTMLTableColElement
-instance IsNode HTMLTableColElement
-instance IsEventTarget HTMLTableColElement
-instance IsGObject HTMLTableColElement where
-  toGObject = GObject . unHTMLTableColElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = HTMLTableColElement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToHTMLTableColElement :: IsGObject obj => obj -> IO HTMLTableColElement
-castToHTMLTableColElement = castTo gTypeHTMLTableColElement "HTMLTableColElement"
-
-foreign import javascript unsafe "window[\"HTMLTableColElement\"]" gTypeHTMLTableColElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.HTMLTableElement".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.HTMLElement"
---     * "GHCJS.DOM.Element"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/HTMLTableElement Mozilla HTMLTableElement documentation>
-newtype HTMLTableElement = HTMLTableElement { unHTMLTableElement :: JSVal }
-
-instance Eq (HTMLTableElement) where
-  (HTMLTableElement a) == (HTMLTableElement b) = js_eq a b
-
-instance PToJSVal HTMLTableElement where
-  pToJSVal = unHTMLTableElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal HTMLTableElement where
-  pFromJSVal = HTMLTableElement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal HTMLTableElement where
-  toJSVal = return . unHTMLTableElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal HTMLTableElement where
-  fromJSVal = return . fmap HTMLTableElement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsHTMLElement HTMLTableElement
-instance IsElement HTMLTableElement
-instance IsNode HTMLTableElement
-instance IsEventTarget HTMLTableElement
-instance IsGObject HTMLTableElement where
-  toGObject = GObject . unHTMLTableElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = HTMLTableElement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToHTMLTableElement :: IsGObject obj => obj -> IO HTMLTableElement
-castToHTMLTableElement = castTo gTypeHTMLTableElement "HTMLTableElement"
-
-foreign import javascript unsafe "window[\"HTMLTableElement\"]" gTypeHTMLTableElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.HTMLTableRowElement".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.HTMLElement"
---     * "GHCJS.DOM.Element"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/HTMLTableRowElement Mozilla HTMLTableRowElement documentation>
-newtype HTMLTableRowElement = HTMLTableRowElement { unHTMLTableRowElement :: JSVal }
-
-instance Eq (HTMLTableRowElement) where
-  (HTMLTableRowElement a) == (HTMLTableRowElement b) = js_eq a b
-
-instance PToJSVal HTMLTableRowElement where
-  pToJSVal = unHTMLTableRowElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal HTMLTableRowElement where
-  pFromJSVal = HTMLTableRowElement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal HTMLTableRowElement where
-  toJSVal = return . unHTMLTableRowElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal HTMLTableRowElement where
-  fromJSVal = return . fmap HTMLTableRowElement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsHTMLElement HTMLTableRowElement
-instance IsElement HTMLTableRowElement
-instance IsNode HTMLTableRowElement
-instance IsEventTarget HTMLTableRowElement
-instance IsGObject HTMLTableRowElement where
-  toGObject = GObject . unHTMLTableRowElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = HTMLTableRowElement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToHTMLTableRowElement :: IsGObject obj => obj -> IO HTMLTableRowElement
-castToHTMLTableRowElement = castTo gTypeHTMLTableRowElement "HTMLTableRowElement"
-
-foreign import javascript unsafe "window[\"HTMLTableRowElement\"]" gTypeHTMLTableRowElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.HTMLTableSectionElement".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.HTMLElement"
---     * "GHCJS.DOM.Element"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/HTMLTableSectionElement Mozilla HTMLTableSectionElement documentation>
-newtype HTMLTableSectionElement = HTMLTableSectionElement { unHTMLTableSectionElement :: JSVal }
-
-instance Eq (HTMLTableSectionElement) where
-  (HTMLTableSectionElement a) == (HTMLTableSectionElement b) = js_eq a b
-
-instance PToJSVal HTMLTableSectionElement where
-  pToJSVal = unHTMLTableSectionElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal HTMLTableSectionElement where
-  pFromJSVal = HTMLTableSectionElement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal HTMLTableSectionElement where
-  toJSVal = return . unHTMLTableSectionElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal HTMLTableSectionElement where
-  fromJSVal = return . fmap HTMLTableSectionElement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsHTMLElement HTMLTableSectionElement
-instance IsElement HTMLTableSectionElement
-instance IsNode HTMLTableSectionElement
-instance IsEventTarget HTMLTableSectionElement
-instance IsGObject HTMLTableSectionElement where
-  toGObject = GObject . unHTMLTableSectionElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = HTMLTableSectionElement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToHTMLTableSectionElement :: IsGObject obj => obj -> IO HTMLTableSectionElement
-castToHTMLTableSectionElement = castTo gTypeHTMLTableSectionElement "HTMLTableSectionElement"
-
-foreign import javascript unsafe "window[\"HTMLTableSectionElement\"]" gTypeHTMLTableSectionElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.HTMLTemplateElement".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.HTMLElement"
---     * "GHCJS.DOM.Element"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/HTMLTemplateElement Mozilla HTMLTemplateElement documentation>
-newtype HTMLTemplateElement = HTMLTemplateElement { unHTMLTemplateElement :: JSVal }
-
-instance Eq (HTMLTemplateElement) where
-  (HTMLTemplateElement a) == (HTMLTemplateElement b) = js_eq a b
-
-instance PToJSVal HTMLTemplateElement where
-  pToJSVal = unHTMLTemplateElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal HTMLTemplateElement where
-  pFromJSVal = HTMLTemplateElement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal HTMLTemplateElement where
-  toJSVal = return . unHTMLTemplateElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal HTMLTemplateElement where
-  fromJSVal = return . fmap HTMLTemplateElement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsHTMLElement HTMLTemplateElement
-instance IsElement HTMLTemplateElement
-instance IsNode HTMLTemplateElement
-instance IsEventTarget HTMLTemplateElement
-instance IsGObject HTMLTemplateElement where
-  toGObject = GObject . unHTMLTemplateElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = HTMLTemplateElement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToHTMLTemplateElement :: IsGObject obj => obj -> IO HTMLTemplateElement
-castToHTMLTemplateElement = castTo gTypeHTMLTemplateElement "HTMLTemplateElement"
-
-foreign import javascript unsafe "window[\"HTMLTemplateElement\"]" gTypeHTMLTemplateElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.HTMLTextAreaElement".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.HTMLElement"
---     * "GHCJS.DOM.Element"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/HTMLTextAreaElement Mozilla HTMLTextAreaElement documentation>
-newtype HTMLTextAreaElement = HTMLTextAreaElement { unHTMLTextAreaElement :: JSVal }
-
-instance Eq (HTMLTextAreaElement) where
-  (HTMLTextAreaElement a) == (HTMLTextAreaElement b) = js_eq a b
-
-instance PToJSVal HTMLTextAreaElement where
-  pToJSVal = unHTMLTextAreaElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal HTMLTextAreaElement where
-  pFromJSVal = HTMLTextAreaElement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal HTMLTextAreaElement where
-  toJSVal = return . unHTMLTextAreaElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal HTMLTextAreaElement where
-  fromJSVal = return . fmap HTMLTextAreaElement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsHTMLElement HTMLTextAreaElement
-instance IsElement HTMLTextAreaElement
-instance IsNode HTMLTextAreaElement
-instance IsEventTarget HTMLTextAreaElement
-instance IsGObject HTMLTextAreaElement where
-  toGObject = GObject . unHTMLTextAreaElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = HTMLTextAreaElement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToHTMLTextAreaElement :: IsGObject obj => obj -> IO HTMLTextAreaElement
-castToHTMLTextAreaElement = castTo gTypeHTMLTextAreaElement "HTMLTextAreaElement"
-
-foreign import javascript unsafe "window[\"HTMLTextAreaElement\"]" gTypeHTMLTextAreaElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.HTMLTitleElement".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.HTMLElement"
---     * "GHCJS.DOM.Element"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/HTMLTitleElement Mozilla HTMLTitleElement documentation>
-newtype HTMLTitleElement = HTMLTitleElement { unHTMLTitleElement :: JSVal }
-
-instance Eq (HTMLTitleElement) where
-  (HTMLTitleElement a) == (HTMLTitleElement b) = js_eq a b
-
-instance PToJSVal HTMLTitleElement where
-  pToJSVal = unHTMLTitleElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal HTMLTitleElement where
-  pFromJSVal = HTMLTitleElement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal HTMLTitleElement where
-  toJSVal = return . unHTMLTitleElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal HTMLTitleElement where
-  fromJSVal = return . fmap HTMLTitleElement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsHTMLElement HTMLTitleElement
-instance IsElement HTMLTitleElement
-instance IsNode HTMLTitleElement
-instance IsEventTarget HTMLTitleElement
-instance IsGObject HTMLTitleElement where
-  toGObject = GObject . unHTMLTitleElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = HTMLTitleElement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToHTMLTitleElement :: IsGObject obj => obj -> IO HTMLTitleElement
-castToHTMLTitleElement = castTo gTypeHTMLTitleElement "HTMLTitleElement"
-
-foreign import javascript unsafe "window[\"HTMLTitleElement\"]" gTypeHTMLTitleElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.HTMLTrackElement".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.HTMLElement"
---     * "GHCJS.DOM.Element"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/HTMLTrackElement Mozilla HTMLTrackElement documentation>
-newtype HTMLTrackElement = HTMLTrackElement { unHTMLTrackElement :: JSVal }
-
-instance Eq (HTMLTrackElement) where
-  (HTMLTrackElement a) == (HTMLTrackElement b) = js_eq a b
-
-instance PToJSVal HTMLTrackElement where
-  pToJSVal = unHTMLTrackElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal HTMLTrackElement where
-  pFromJSVal = HTMLTrackElement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal HTMLTrackElement where
-  toJSVal = return . unHTMLTrackElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal HTMLTrackElement where
-  fromJSVal = return . fmap HTMLTrackElement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsHTMLElement HTMLTrackElement
-instance IsElement HTMLTrackElement
-instance IsNode HTMLTrackElement
-instance IsEventTarget HTMLTrackElement
-instance IsGObject HTMLTrackElement where
-  toGObject = GObject . unHTMLTrackElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = HTMLTrackElement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToHTMLTrackElement :: IsGObject obj => obj -> IO HTMLTrackElement
-castToHTMLTrackElement = castTo gTypeHTMLTrackElement "HTMLTrackElement"
-
-foreign import javascript unsafe "window[\"HTMLTrackElement\"]" gTypeHTMLTrackElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.HTMLUListElement".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.HTMLElement"
---     * "GHCJS.DOM.Element"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/HTMLUListElement Mozilla HTMLUListElement documentation>
-newtype HTMLUListElement = HTMLUListElement { unHTMLUListElement :: JSVal }
-
-instance Eq (HTMLUListElement) where
-  (HTMLUListElement a) == (HTMLUListElement b) = js_eq a b
-
-instance PToJSVal HTMLUListElement where
-  pToJSVal = unHTMLUListElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal HTMLUListElement where
-  pFromJSVal = HTMLUListElement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal HTMLUListElement where
-  toJSVal = return . unHTMLUListElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal HTMLUListElement where
-  fromJSVal = return . fmap HTMLUListElement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsHTMLElement HTMLUListElement
-instance IsElement HTMLUListElement
-instance IsNode HTMLUListElement
-instance IsEventTarget HTMLUListElement
-instance IsGObject HTMLUListElement where
-  toGObject = GObject . unHTMLUListElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = HTMLUListElement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToHTMLUListElement :: IsGObject obj => obj -> IO HTMLUListElement
-castToHTMLUListElement = castTo gTypeHTMLUListElement "HTMLUListElement"
-
-foreign import javascript unsafe "window[\"HTMLUListElement\"]" gTypeHTMLUListElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.HTMLUnknownElement".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.HTMLElement"
---     * "GHCJS.DOM.Element"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/HTMLUnknownElement Mozilla HTMLUnknownElement documentation>
-newtype HTMLUnknownElement = HTMLUnknownElement { unHTMLUnknownElement :: JSVal }
-
-instance Eq (HTMLUnknownElement) where
-  (HTMLUnknownElement a) == (HTMLUnknownElement b) = js_eq a b
-
-instance PToJSVal HTMLUnknownElement where
-  pToJSVal = unHTMLUnknownElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal HTMLUnknownElement where
-  pFromJSVal = HTMLUnknownElement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal HTMLUnknownElement where
-  toJSVal = return . unHTMLUnknownElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal HTMLUnknownElement where
-  fromJSVal = return . fmap HTMLUnknownElement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsHTMLElement HTMLUnknownElement
-instance IsElement HTMLUnknownElement
-instance IsNode HTMLUnknownElement
-instance IsEventTarget HTMLUnknownElement
-instance IsGObject HTMLUnknownElement where
-  toGObject = GObject . unHTMLUnknownElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = HTMLUnknownElement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToHTMLUnknownElement :: IsGObject obj => obj -> IO HTMLUnknownElement
-castToHTMLUnknownElement = castTo gTypeHTMLUnknownElement "HTMLUnknownElement"
-
-foreign import javascript unsafe "window[\"HTMLUnknownElement\"]" gTypeHTMLUnknownElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.HTMLVideoElement".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.HTMLMediaElement"
---     * "GHCJS.DOM.HTMLElement"
---     * "GHCJS.DOM.Element"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/HTMLVideoElement Mozilla HTMLVideoElement documentation>
-newtype HTMLVideoElement = HTMLVideoElement { unHTMLVideoElement :: JSVal }
-
-instance Eq (HTMLVideoElement) where
-  (HTMLVideoElement a) == (HTMLVideoElement b) = js_eq a b
-
-instance PToJSVal HTMLVideoElement where
-  pToJSVal = unHTMLVideoElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal HTMLVideoElement where
-  pFromJSVal = HTMLVideoElement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal HTMLVideoElement where
-  toJSVal = return . unHTMLVideoElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal HTMLVideoElement where
-  fromJSVal = return . fmap HTMLVideoElement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsHTMLMediaElement HTMLVideoElement
-instance IsHTMLElement HTMLVideoElement
-instance IsElement HTMLVideoElement
-instance IsNode HTMLVideoElement
-instance IsEventTarget HTMLVideoElement
-instance IsGObject HTMLVideoElement where
-  toGObject = GObject . unHTMLVideoElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = HTMLVideoElement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToHTMLVideoElement :: IsGObject obj => obj -> IO HTMLVideoElement
-castToHTMLVideoElement = castTo gTypeHTMLVideoElement "HTMLVideoElement"
-
-foreign import javascript unsafe "window[\"HTMLVideoElement\"]" gTypeHTMLVideoElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.HashChangeEvent".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.Event"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/HashChangeEvent Mozilla HashChangeEvent documentation>
-newtype HashChangeEvent = HashChangeEvent { unHashChangeEvent :: JSVal }
-
-instance Eq (HashChangeEvent) where
-  (HashChangeEvent a) == (HashChangeEvent b) = js_eq a b
-
-instance PToJSVal HashChangeEvent where
-  pToJSVal = unHashChangeEvent
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal HashChangeEvent where
-  pFromJSVal = HashChangeEvent
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal HashChangeEvent where
-  toJSVal = return . unHashChangeEvent
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal HashChangeEvent where
-  fromJSVal = return . fmap HashChangeEvent . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsEvent HashChangeEvent
-instance IsGObject HashChangeEvent where
-  toGObject = GObject . unHashChangeEvent
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = HashChangeEvent . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToHashChangeEvent :: IsGObject obj => obj -> IO HashChangeEvent
-castToHashChangeEvent = castTo gTypeHashChangeEvent "HashChangeEvent"
-
-foreign import javascript unsafe "window[\"HashChangeEvent\"]" gTypeHashChangeEvent :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.History".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/History Mozilla History documentation>
-newtype History = History { unHistory :: JSVal }
-
-instance Eq (History) where
-  (History a) == (History b) = js_eq a b
-
-instance PToJSVal History where
-  pToJSVal = unHistory
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal History where
-  pFromJSVal = History
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal History where
-  toJSVal = return . unHistory
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal History where
-  fromJSVal = return . fmap History . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject History where
-  toGObject = GObject . unHistory
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = History . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToHistory :: IsGObject obj => obj -> IO History
-castToHistory = castTo gTypeHistory "History"
-
-foreign import javascript unsafe "window[\"History\"]" gTypeHistory :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.IDBAny".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/IDBAny Mozilla IDBAny documentation>
-newtype IDBAny = IDBAny { unIDBAny :: JSVal }
-
-instance Eq (IDBAny) where
-  (IDBAny a) == (IDBAny b) = js_eq a b
-
-instance PToJSVal IDBAny where
-  pToJSVal = unIDBAny
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal IDBAny where
-  pFromJSVal = IDBAny
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal IDBAny where
-  toJSVal = return . unIDBAny
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal IDBAny where
-  fromJSVal = return . fmap IDBAny . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject IDBAny where
-  toGObject = GObject . unIDBAny
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = IDBAny . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToIDBAny :: IsGObject obj => obj -> IO IDBAny
-castToIDBAny = castTo gTypeIDBAny "IDBAny"
-
-foreign import javascript unsafe "window[\"IDBAny\"]" gTypeIDBAny :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.IDBCursor".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/IDBCursor Mozilla IDBCursor documentation>
-newtype IDBCursor = IDBCursor { unIDBCursor :: JSVal }
-
-instance Eq (IDBCursor) where
-  (IDBCursor a) == (IDBCursor b) = js_eq a b
-
-instance PToJSVal IDBCursor where
-  pToJSVal = unIDBCursor
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal IDBCursor where
-  pFromJSVal = IDBCursor
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal IDBCursor where
-  toJSVal = return . unIDBCursor
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal IDBCursor where
-  fromJSVal = return . fmap IDBCursor . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-class IsGObject o => IsIDBCursor o
-toIDBCursor :: IsIDBCursor o => o -> IDBCursor
-toIDBCursor = unsafeCastGObject . toGObject
-
-instance IsIDBCursor IDBCursor
-instance IsGObject IDBCursor where
-  toGObject = GObject . unIDBCursor
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = IDBCursor . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToIDBCursor :: IsGObject obj => obj -> IO IDBCursor
-castToIDBCursor = castTo gTypeIDBCursor "IDBCursor"
-
-foreign import javascript unsafe "window[\"IDBCursor\"]" gTypeIDBCursor :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.IDBCursorWithValue".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.IDBCursor"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/IDBCursorWithValue Mozilla IDBCursorWithValue documentation>
-newtype IDBCursorWithValue = IDBCursorWithValue { unIDBCursorWithValue :: JSVal }
-
-instance Eq (IDBCursorWithValue) where
-  (IDBCursorWithValue a) == (IDBCursorWithValue b) = js_eq a b
-
-instance PToJSVal IDBCursorWithValue where
-  pToJSVal = unIDBCursorWithValue
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal IDBCursorWithValue where
-  pFromJSVal = IDBCursorWithValue
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal IDBCursorWithValue where
-  toJSVal = return . unIDBCursorWithValue
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal IDBCursorWithValue where
-  fromJSVal = return . fmap IDBCursorWithValue . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsIDBCursor IDBCursorWithValue
-instance IsGObject IDBCursorWithValue where
-  toGObject = GObject . unIDBCursorWithValue
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = IDBCursorWithValue . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToIDBCursorWithValue :: IsGObject obj => obj -> IO IDBCursorWithValue
-castToIDBCursorWithValue = castTo gTypeIDBCursorWithValue "IDBCursorWithValue"
-
-foreign import javascript unsafe "window[\"IDBCursorWithValue\"]" gTypeIDBCursorWithValue :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.IDBDatabase".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/IDBDatabase Mozilla IDBDatabase documentation>
-newtype IDBDatabase = IDBDatabase { unIDBDatabase :: JSVal }
-
-instance Eq (IDBDatabase) where
-  (IDBDatabase a) == (IDBDatabase b) = js_eq a b
-
-instance PToJSVal IDBDatabase where
-  pToJSVal = unIDBDatabase
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal IDBDatabase where
-  pFromJSVal = IDBDatabase
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal IDBDatabase where
-  toJSVal = return . unIDBDatabase
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal IDBDatabase where
-  fromJSVal = return . fmap IDBDatabase . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsEventTarget IDBDatabase
-instance IsGObject IDBDatabase where
-  toGObject = GObject . unIDBDatabase
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = IDBDatabase . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToIDBDatabase :: IsGObject obj => obj -> IO IDBDatabase
-castToIDBDatabase = castTo gTypeIDBDatabase "IDBDatabase"
-
-foreign import javascript unsafe "window[\"IDBDatabase\"]" gTypeIDBDatabase :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.IDBFactory".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/IDBFactory Mozilla IDBFactory documentation>
-newtype IDBFactory = IDBFactory { unIDBFactory :: JSVal }
-
-instance Eq (IDBFactory) where
-  (IDBFactory a) == (IDBFactory b) = js_eq a b
-
-instance PToJSVal IDBFactory where
-  pToJSVal = unIDBFactory
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal IDBFactory where
-  pFromJSVal = IDBFactory
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal IDBFactory where
-  toJSVal = return . unIDBFactory
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal IDBFactory where
-  fromJSVal = return . fmap IDBFactory . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject IDBFactory where
-  toGObject = GObject . unIDBFactory
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = IDBFactory . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToIDBFactory :: IsGObject obj => obj -> IO IDBFactory
-castToIDBFactory = castTo gTypeIDBFactory "IDBFactory"
-
-foreign import javascript unsafe "window[\"IDBFactory\"]" gTypeIDBFactory :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.IDBIndex".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/IDBIndex Mozilla IDBIndex documentation>
-newtype IDBIndex = IDBIndex { unIDBIndex :: JSVal }
-
-instance Eq (IDBIndex) where
-  (IDBIndex a) == (IDBIndex b) = js_eq a b
-
-instance PToJSVal IDBIndex where
-  pToJSVal = unIDBIndex
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal IDBIndex where
-  pFromJSVal = IDBIndex
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal IDBIndex where
-  toJSVal = return . unIDBIndex
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal IDBIndex where
-  fromJSVal = return . fmap IDBIndex . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject IDBIndex where
-  toGObject = GObject . unIDBIndex
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = IDBIndex . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToIDBIndex :: IsGObject obj => obj -> IO IDBIndex
-castToIDBIndex = castTo gTypeIDBIndex "IDBIndex"
-
-foreign import javascript unsafe "window[\"IDBIndex\"]" gTypeIDBIndex :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.IDBKeyRange".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/IDBKeyRange Mozilla IDBKeyRange documentation>
-newtype IDBKeyRange = IDBKeyRange { unIDBKeyRange :: JSVal }
-
-instance Eq (IDBKeyRange) where
-  (IDBKeyRange a) == (IDBKeyRange b) = js_eq a b
-
-instance PToJSVal IDBKeyRange where
-  pToJSVal = unIDBKeyRange
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal IDBKeyRange where
-  pFromJSVal = IDBKeyRange
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal IDBKeyRange where
-  toJSVal = return . unIDBKeyRange
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal IDBKeyRange where
-  fromJSVal = return . fmap IDBKeyRange . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject IDBKeyRange where
-  toGObject = GObject . unIDBKeyRange
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = IDBKeyRange . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToIDBKeyRange :: IsGObject obj => obj -> IO IDBKeyRange
-castToIDBKeyRange = castTo gTypeIDBKeyRange "IDBKeyRange"
-
-foreign import javascript unsafe "window[\"IDBKeyRange\"]" gTypeIDBKeyRange :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.IDBObjectStore".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/IDBObjectStore Mozilla IDBObjectStore documentation>
-newtype IDBObjectStore = IDBObjectStore { unIDBObjectStore :: JSVal }
-
-instance Eq (IDBObjectStore) where
-  (IDBObjectStore a) == (IDBObjectStore b) = js_eq a b
-
-instance PToJSVal IDBObjectStore where
-  pToJSVal = unIDBObjectStore
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal IDBObjectStore where
-  pFromJSVal = IDBObjectStore
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal IDBObjectStore where
-  toJSVal = return . unIDBObjectStore
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal IDBObjectStore where
-  fromJSVal = return . fmap IDBObjectStore . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject IDBObjectStore where
-  toGObject = GObject . unIDBObjectStore
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = IDBObjectStore . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToIDBObjectStore :: IsGObject obj => obj -> IO IDBObjectStore
-castToIDBObjectStore = castTo gTypeIDBObjectStore "IDBObjectStore"
-
-foreign import javascript unsafe "window[\"IDBObjectStore\"]" gTypeIDBObjectStore :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.IDBOpenDBRequest".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.IDBRequest"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/IDBOpenDBRequest Mozilla IDBOpenDBRequest documentation>
-newtype IDBOpenDBRequest = IDBOpenDBRequest { unIDBOpenDBRequest :: JSVal }
-
-instance Eq (IDBOpenDBRequest) where
-  (IDBOpenDBRequest a) == (IDBOpenDBRequest b) = js_eq a b
-
-instance PToJSVal IDBOpenDBRequest where
-  pToJSVal = unIDBOpenDBRequest
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal IDBOpenDBRequest where
-  pFromJSVal = IDBOpenDBRequest
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal IDBOpenDBRequest where
-  toJSVal = return . unIDBOpenDBRequest
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal IDBOpenDBRequest where
-  fromJSVal = return . fmap IDBOpenDBRequest . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsIDBRequest IDBOpenDBRequest
-instance IsEventTarget IDBOpenDBRequest
-instance IsGObject IDBOpenDBRequest where
-  toGObject = GObject . unIDBOpenDBRequest
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = IDBOpenDBRequest . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToIDBOpenDBRequest :: IsGObject obj => obj -> IO IDBOpenDBRequest
-castToIDBOpenDBRequest = castTo gTypeIDBOpenDBRequest "IDBOpenDBRequest"
-
-foreign import javascript unsafe "window[\"IDBOpenDBRequest\"]" gTypeIDBOpenDBRequest :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.IDBRequest".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/IDBRequest Mozilla IDBRequest documentation>
-newtype IDBRequest = IDBRequest { unIDBRequest :: JSVal }
-
-instance Eq (IDBRequest) where
-  (IDBRequest a) == (IDBRequest b) = js_eq a b
-
-instance PToJSVal IDBRequest where
-  pToJSVal = unIDBRequest
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal IDBRequest where
-  pFromJSVal = IDBRequest
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal IDBRequest where
-  toJSVal = return . unIDBRequest
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal IDBRequest where
-  fromJSVal = return . fmap IDBRequest . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-class IsEventTarget o => IsIDBRequest o
-toIDBRequest :: IsIDBRequest o => o -> IDBRequest
-toIDBRequest = unsafeCastGObject . toGObject
-
-instance IsIDBRequest IDBRequest
-instance IsEventTarget IDBRequest
-instance IsGObject IDBRequest where
-  toGObject = GObject . unIDBRequest
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = IDBRequest . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToIDBRequest :: IsGObject obj => obj -> IO IDBRequest
-castToIDBRequest = castTo gTypeIDBRequest "IDBRequest"
-
-foreign import javascript unsafe "window[\"IDBRequest\"]" gTypeIDBRequest :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.IDBTransaction".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/IDBTransaction Mozilla IDBTransaction documentation>
-newtype IDBTransaction = IDBTransaction { unIDBTransaction :: JSVal }
-
-instance Eq (IDBTransaction) where
-  (IDBTransaction a) == (IDBTransaction b) = js_eq a b
-
-instance PToJSVal IDBTransaction where
-  pToJSVal = unIDBTransaction
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal IDBTransaction where
-  pFromJSVal = IDBTransaction
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal IDBTransaction where
-  toJSVal = return . unIDBTransaction
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal IDBTransaction where
-  fromJSVal = return . fmap IDBTransaction . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsEventTarget IDBTransaction
-instance IsGObject IDBTransaction where
-  toGObject = GObject . unIDBTransaction
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = IDBTransaction . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToIDBTransaction :: IsGObject obj => obj -> IO IDBTransaction
-castToIDBTransaction = castTo gTypeIDBTransaction "IDBTransaction"
-
-foreign import javascript unsafe "window[\"IDBTransaction\"]" gTypeIDBTransaction :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.IDBVersionChangeEvent".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.Event"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/IDBVersionChangeEvent Mozilla IDBVersionChangeEvent documentation>
-newtype IDBVersionChangeEvent = IDBVersionChangeEvent { unIDBVersionChangeEvent :: JSVal }
-
-instance Eq (IDBVersionChangeEvent) where
-  (IDBVersionChangeEvent a) == (IDBVersionChangeEvent b) = js_eq a b
-
-instance PToJSVal IDBVersionChangeEvent where
-  pToJSVal = unIDBVersionChangeEvent
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal IDBVersionChangeEvent where
-  pFromJSVal = IDBVersionChangeEvent
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal IDBVersionChangeEvent where
-  toJSVal = return . unIDBVersionChangeEvent
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal IDBVersionChangeEvent where
-  fromJSVal = return . fmap IDBVersionChangeEvent . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsEvent IDBVersionChangeEvent
-instance IsGObject IDBVersionChangeEvent where
-  toGObject = GObject . unIDBVersionChangeEvent
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = IDBVersionChangeEvent . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToIDBVersionChangeEvent :: IsGObject obj => obj -> IO IDBVersionChangeEvent
-castToIDBVersionChangeEvent = castTo gTypeIDBVersionChangeEvent "IDBVersionChangeEvent"
-
-foreign import javascript unsafe "window[\"IDBVersionChangeEvent\"]" gTypeIDBVersionChangeEvent :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.ImageData".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/ImageData Mozilla ImageData documentation>
-newtype ImageData = ImageData { unImageData :: JSVal }
-
-instance Eq (ImageData) where
-  (ImageData a) == (ImageData b) = js_eq a b
-
-instance PToJSVal ImageData where
-  pToJSVal = unImageData
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal ImageData where
-  pFromJSVal = ImageData
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal ImageData where
-  toJSVal = return . unImageData
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal ImageData where
-  fromJSVal = return . fmap ImageData . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject ImageData where
-  toGObject = GObject . unImageData
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = ImageData . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToImageData :: IsGObject obj => obj -> IO ImageData
-castToImageData = castTo gTypeImageData "ImageData"
-
-foreign import javascript unsafe "window[\"ImageData\"]" gTypeImageData :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.InspectorFrontendHost".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/InspectorFrontendHost Mozilla InspectorFrontendHost documentation>
-newtype InspectorFrontendHost = InspectorFrontendHost { unInspectorFrontendHost :: JSVal }
-
-instance Eq (InspectorFrontendHost) where
-  (InspectorFrontendHost a) == (InspectorFrontendHost b) = js_eq a b
-
-instance PToJSVal InspectorFrontendHost where
-  pToJSVal = unInspectorFrontendHost
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal InspectorFrontendHost where
-  pFromJSVal = InspectorFrontendHost
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal InspectorFrontendHost where
-  toJSVal = return . unInspectorFrontendHost
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal InspectorFrontendHost where
-  fromJSVal = return . fmap InspectorFrontendHost . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject InspectorFrontendHost where
-  toGObject = GObject . unInspectorFrontendHost
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = InspectorFrontendHost . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToInspectorFrontendHost :: IsGObject obj => obj -> IO InspectorFrontendHost
-castToInspectorFrontendHost = castTo gTypeInspectorFrontendHost "InspectorFrontendHost"
-
-foreign import javascript unsafe "window[\"InspectorFrontendHost\"]" gTypeInspectorFrontendHost :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.InternalSettings".
--- Base interface functions are in:
---
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/InternalSettings Mozilla InternalSettings documentation>
-newtype InternalSettings = InternalSettings { unInternalSettings :: JSVal }
-
-instance Eq (InternalSettings) where
-  (InternalSettings a) == (InternalSettings b) = js_eq a b
-
-instance PToJSVal InternalSettings where
-  pToJSVal = unInternalSettings
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal InternalSettings where
-  pFromJSVal = InternalSettings
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal InternalSettings where
-  toJSVal = return . unInternalSettings
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal InternalSettings where
-  fromJSVal = return . fmap InternalSettings . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject InternalSettings where
-  toGObject = GObject . unInternalSettings
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = InternalSettings . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToInternalSettings :: IsGObject obj => obj -> IO InternalSettings
-castToInternalSettings = castTo gTypeInternalSettings "InternalSettings"
-
-foreign import javascript unsafe "window[\"InternalSettings\"]" gTypeInternalSettings :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.Internals".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/Internals Mozilla Internals documentation>
-newtype Internals = Internals { unInternals :: JSVal }
-
-instance Eq (Internals) where
-  (Internals a) == (Internals b) = js_eq a b
-
-instance PToJSVal Internals where
-  pToJSVal = unInternals
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal Internals where
-  pFromJSVal = Internals
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal Internals where
-  toJSVal = return . unInternals
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal Internals where
-  fromJSVal = return . fmap Internals . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject Internals where
-  toGObject = GObject . unInternals
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = Internals . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToInternals :: IsGObject obj => obj -> IO Internals
-castToInternals = castTo gTypeInternals "Internals"
-
-foreign import javascript unsafe "window[\"Internals\"]" gTypeInternals :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.KeyboardEvent".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.UIEvent"
---     * "GHCJS.DOM.Event"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent Mozilla KeyboardEvent documentation>
-newtype KeyboardEvent = KeyboardEvent { unKeyboardEvent :: JSVal }
-
-instance Eq (KeyboardEvent) where
-  (KeyboardEvent a) == (KeyboardEvent b) = js_eq a b
-
-instance PToJSVal KeyboardEvent where
-  pToJSVal = unKeyboardEvent
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal KeyboardEvent where
-  pFromJSVal = KeyboardEvent
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal KeyboardEvent where
-  toJSVal = return . unKeyboardEvent
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal KeyboardEvent where
-  fromJSVal = return . fmap KeyboardEvent . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsUIEvent KeyboardEvent
-instance IsEvent KeyboardEvent
-instance IsGObject KeyboardEvent where
-  toGObject = GObject . unKeyboardEvent
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = KeyboardEvent . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToKeyboardEvent :: IsGObject obj => obj -> IO KeyboardEvent
-castToKeyboardEvent = castTo gTypeKeyboardEvent "KeyboardEvent"
-
-foreign import javascript unsafe "window[\"KeyboardEvent\"]" gTypeKeyboardEvent :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.Location".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/Location Mozilla Location documentation>
-newtype Location = Location { unLocation :: JSVal }
-
-instance Eq (Location) where
-  (Location a) == (Location b) = js_eq a b
-
-instance PToJSVal Location where
-  pToJSVal = unLocation
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal Location where
-  pFromJSVal = Location
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal Location where
-  toJSVal = return . unLocation
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal Location where
-  fromJSVal = return . fmap Location . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject Location where
-  toGObject = GObject . unLocation
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = Location . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToLocation :: IsGObject obj => obj -> IO Location
-castToLocation = castTo gTypeLocation "Location"
-
-foreign import javascript unsafe "window[\"Location\"]" gTypeLocation :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.MallocStatistics".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/MallocStatistics Mozilla MallocStatistics documentation>
-newtype MallocStatistics = MallocStatistics { unMallocStatistics :: JSVal }
-
-instance Eq (MallocStatistics) where
-  (MallocStatistics a) == (MallocStatistics b) = js_eq a b
-
-instance PToJSVal MallocStatistics where
-  pToJSVal = unMallocStatistics
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal MallocStatistics where
-  pFromJSVal = MallocStatistics
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal MallocStatistics where
-  toJSVal = return . unMallocStatistics
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal MallocStatistics where
-  fromJSVal = return . fmap MallocStatistics . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject MallocStatistics where
-  toGObject = GObject . unMallocStatistics
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = MallocStatistics . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToMallocStatistics :: IsGObject obj => obj -> IO MallocStatistics
-castToMallocStatistics = castTo gTypeMallocStatistics "MallocStatistics"
-
-foreign import javascript unsafe "window[\"MallocStatistics\"]" gTypeMallocStatistics :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.MediaController".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/MediaController Mozilla MediaController documentation>
-newtype MediaController = MediaController { unMediaController :: JSVal }
-
-instance Eq (MediaController) where
-  (MediaController a) == (MediaController b) = js_eq a b
-
-instance PToJSVal MediaController where
-  pToJSVal = unMediaController
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal MediaController where
-  pFromJSVal = MediaController
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal MediaController where
-  toJSVal = return . unMediaController
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal MediaController where
-  fromJSVal = return . fmap MediaController . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsEventTarget MediaController
-instance IsGObject MediaController where
-  toGObject = GObject . unMediaController
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = MediaController . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToMediaController :: IsGObject obj => obj -> IO MediaController
-castToMediaController = castTo gTypeMediaController "MediaController"
-
-foreign import javascript unsafe "window[\"MediaController\"]" gTypeMediaController :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.MediaControlsHost".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/MediaControlsHost Mozilla MediaControlsHost documentation>
-newtype MediaControlsHost = MediaControlsHost { unMediaControlsHost :: JSVal }
-
-instance Eq (MediaControlsHost) where
-  (MediaControlsHost a) == (MediaControlsHost b) = js_eq a b
-
-instance PToJSVal MediaControlsHost where
-  pToJSVal = unMediaControlsHost
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal MediaControlsHost where
-  pFromJSVal = MediaControlsHost
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal MediaControlsHost where
-  toJSVal = return . unMediaControlsHost
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal MediaControlsHost where
-  fromJSVal = return . fmap MediaControlsHost . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject MediaControlsHost where
-  toGObject = GObject . unMediaControlsHost
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = MediaControlsHost . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToMediaControlsHost :: IsGObject obj => obj -> IO MediaControlsHost
-castToMediaControlsHost = castTo gTypeMediaControlsHost "MediaControlsHost"
-
-foreign import javascript unsafe "window[\"MediaControlsHost\"]" gTypeMediaControlsHost :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.MediaElementAudioSourceNode".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.AudioNode"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/MediaElementAudioSourceNode Mozilla MediaElementAudioSourceNode documentation>
-newtype MediaElementAudioSourceNode = MediaElementAudioSourceNode { unMediaElementAudioSourceNode :: JSVal }
-
-instance Eq (MediaElementAudioSourceNode) where
-  (MediaElementAudioSourceNode a) == (MediaElementAudioSourceNode b) = js_eq a b
-
-instance PToJSVal MediaElementAudioSourceNode where
-  pToJSVal = unMediaElementAudioSourceNode
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal MediaElementAudioSourceNode where
-  pFromJSVal = MediaElementAudioSourceNode
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal MediaElementAudioSourceNode where
-  toJSVal = return . unMediaElementAudioSourceNode
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal MediaElementAudioSourceNode where
-  fromJSVal = return . fmap MediaElementAudioSourceNode . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsAudioNode MediaElementAudioSourceNode
-instance IsEventTarget MediaElementAudioSourceNode
-instance IsGObject MediaElementAudioSourceNode where
-  toGObject = GObject . unMediaElementAudioSourceNode
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = MediaElementAudioSourceNode . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToMediaElementAudioSourceNode :: IsGObject obj => obj -> IO MediaElementAudioSourceNode
-castToMediaElementAudioSourceNode = castTo gTypeMediaElementAudioSourceNode "MediaElementAudioSourceNode"
-
-foreign import javascript unsafe "window[\"MediaElementAudioSourceNode\"]" gTypeMediaElementAudioSourceNode :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.MediaError".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/MediaError Mozilla MediaError documentation>
-newtype MediaError = MediaError { unMediaError :: JSVal }
-
-instance Eq (MediaError) where
-  (MediaError a) == (MediaError b) = js_eq a b
-
-instance PToJSVal MediaError where
-  pToJSVal = unMediaError
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal MediaError where
-  pFromJSVal = MediaError
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal MediaError where
-  toJSVal = return . unMediaError
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal MediaError where
-  fromJSVal = return . fmap MediaError . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject MediaError where
-  toGObject = GObject . unMediaError
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = MediaError . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToMediaError :: IsGObject obj => obj -> IO MediaError
-castToMediaError = castTo gTypeMediaError "MediaError"
-
-foreign import javascript unsafe "window[\"MediaError\"]" gTypeMediaError :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.MediaKeyError".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/WebKitMediaKeyError Mozilla WebKitMediaKeyError documentation>
-newtype MediaKeyError = MediaKeyError { unMediaKeyError :: JSVal }
-
-instance Eq (MediaKeyError) where
-  (MediaKeyError a) == (MediaKeyError b) = js_eq a b
-
-instance PToJSVal MediaKeyError where
-  pToJSVal = unMediaKeyError
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal MediaKeyError where
-  pFromJSVal = MediaKeyError
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal MediaKeyError where
-  toJSVal = return . unMediaKeyError
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal MediaKeyError where
-  fromJSVal = return . fmap MediaKeyError . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject MediaKeyError where
-  toGObject = GObject . unMediaKeyError
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = MediaKeyError . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToMediaKeyError :: IsGObject obj => obj -> IO MediaKeyError
-castToMediaKeyError = castTo gTypeMediaKeyError "MediaKeyError"
-
-foreign import javascript unsafe "window[\"WebKitMediaKeyError\"]" gTypeMediaKeyError :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.MediaKeyEvent".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.Event"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/MediaKeyEvent Mozilla MediaKeyEvent documentation>
-newtype MediaKeyEvent = MediaKeyEvent { unMediaKeyEvent :: JSVal }
-
-instance Eq (MediaKeyEvent) where
-  (MediaKeyEvent a) == (MediaKeyEvent b) = js_eq a b
-
-instance PToJSVal MediaKeyEvent where
-  pToJSVal = unMediaKeyEvent
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal MediaKeyEvent where
-  pFromJSVal = MediaKeyEvent
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal MediaKeyEvent where
-  toJSVal = return . unMediaKeyEvent
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal MediaKeyEvent where
-  fromJSVal = return . fmap MediaKeyEvent . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsEvent MediaKeyEvent
-instance IsGObject MediaKeyEvent where
-  toGObject = GObject . unMediaKeyEvent
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = MediaKeyEvent . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToMediaKeyEvent :: IsGObject obj => obj -> IO MediaKeyEvent
-castToMediaKeyEvent = castTo gTypeMediaKeyEvent "MediaKeyEvent"
-
-foreign import javascript unsafe "window[\"MediaKeyEvent\"]" gTypeMediaKeyEvent :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.MediaKeyMessageEvent".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.Event"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/WebKitMediaKeyMessageEvent Mozilla WebKitMediaKeyMessageEvent documentation>
-newtype MediaKeyMessageEvent = MediaKeyMessageEvent { unMediaKeyMessageEvent :: JSVal }
-
-instance Eq (MediaKeyMessageEvent) where
-  (MediaKeyMessageEvent a) == (MediaKeyMessageEvent b) = js_eq a b
-
-instance PToJSVal MediaKeyMessageEvent where
-  pToJSVal = unMediaKeyMessageEvent
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal MediaKeyMessageEvent where
-  pFromJSVal = MediaKeyMessageEvent
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal MediaKeyMessageEvent where
-  toJSVal = return . unMediaKeyMessageEvent
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal MediaKeyMessageEvent where
-  fromJSVal = return . fmap MediaKeyMessageEvent . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsEvent MediaKeyMessageEvent
-instance IsGObject MediaKeyMessageEvent where
-  toGObject = GObject . unMediaKeyMessageEvent
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = MediaKeyMessageEvent . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToMediaKeyMessageEvent :: IsGObject obj => obj -> IO MediaKeyMessageEvent
-castToMediaKeyMessageEvent = castTo gTypeMediaKeyMessageEvent "MediaKeyMessageEvent"
-
-foreign import javascript unsafe "window[\"WebKitMediaKeyMessageEvent\"]" gTypeMediaKeyMessageEvent :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.MediaKeyNeededEvent".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.Event"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/MediaKeyNeededEvent Mozilla MediaKeyNeededEvent documentation>
-newtype MediaKeyNeededEvent = MediaKeyNeededEvent { unMediaKeyNeededEvent :: JSVal }
-
-instance Eq (MediaKeyNeededEvent) where
-  (MediaKeyNeededEvent a) == (MediaKeyNeededEvent b) = js_eq a b
-
-instance PToJSVal MediaKeyNeededEvent where
-  pToJSVal = unMediaKeyNeededEvent
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal MediaKeyNeededEvent where
-  pFromJSVal = MediaKeyNeededEvent
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal MediaKeyNeededEvent where
-  toJSVal = return . unMediaKeyNeededEvent
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal MediaKeyNeededEvent where
-  fromJSVal = return . fmap MediaKeyNeededEvent . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsEvent MediaKeyNeededEvent
-instance IsGObject MediaKeyNeededEvent where
-  toGObject = GObject . unMediaKeyNeededEvent
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = MediaKeyNeededEvent . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToMediaKeyNeededEvent :: IsGObject obj => obj -> IO MediaKeyNeededEvent
-castToMediaKeyNeededEvent = castTo gTypeMediaKeyNeededEvent "MediaKeyNeededEvent"
-
-foreign import javascript unsafe "window[\"MediaKeyNeededEvent\"]" gTypeMediaKeyNeededEvent :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.MediaKeySession".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/WebKitMediaKeySession Mozilla WebKitMediaKeySession documentation>
-newtype MediaKeySession = MediaKeySession { unMediaKeySession :: JSVal }
-
-instance Eq (MediaKeySession) where
-  (MediaKeySession a) == (MediaKeySession b) = js_eq a b
-
-instance PToJSVal MediaKeySession where
-  pToJSVal = unMediaKeySession
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal MediaKeySession where
-  pFromJSVal = MediaKeySession
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal MediaKeySession where
-  toJSVal = return . unMediaKeySession
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal MediaKeySession where
-  fromJSVal = return . fmap MediaKeySession . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsEventTarget MediaKeySession
-instance IsGObject MediaKeySession where
-  toGObject = GObject . unMediaKeySession
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = MediaKeySession . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToMediaKeySession :: IsGObject obj => obj -> IO MediaKeySession
-castToMediaKeySession = castTo gTypeMediaKeySession "MediaKeySession"
-
-foreign import javascript unsafe "window[\"WebKitMediaKeySession\"]" gTypeMediaKeySession :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.MediaKeys".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/WebKitMediaKeys Mozilla WebKitMediaKeys documentation>
-newtype MediaKeys = MediaKeys { unMediaKeys :: JSVal }
-
-instance Eq (MediaKeys) where
-  (MediaKeys a) == (MediaKeys b) = js_eq a b
-
-instance PToJSVal MediaKeys where
-  pToJSVal = unMediaKeys
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal MediaKeys where
-  pFromJSVal = MediaKeys
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal MediaKeys where
-  toJSVal = return . unMediaKeys
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal MediaKeys where
-  fromJSVal = return . fmap MediaKeys . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject MediaKeys where
-  toGObject = GObject . unMediaKeys
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = MediaKeys . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToMediaKeys :: IsGObject obj => obj -> IO MediaKeys
-castToMediaKeys = castTo gTypeMediaKeys "MediaKeys"
-
-foreign import javascript unsafe "window[\"WebKitMediaKeys\"]" gTypeMediaKeys :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.MediaList".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/MediaList Mozilla MediaList documentation>
-newtype MediaList = MediaList { unMediaList :: JSVal }
-
-instance Eq (MediaList) where
-  (MediaList a) == (MediaList b) = js_eq a b
-
-instance PToJSVal MediaList where
-  pToJSVal = unMediaList
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal MediaList where
-  pFromJSVal = MediaList
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal MediaList where
-  toJSVal = return . unMediaList
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal MediaList where
-  fromJSVal = return . fmap MediaList . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject MediaList where
-  toGObject = GObject . unMediaList
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = MediaList . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToMediaList :: IsGObject obj => obj -> IO MediaList
-castToMediaList = castTo gTypeMediaList "MediaList"
-
-foreign import javascript unsafe "window[\"MediaList\"]" gTypeMediaList :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.MediaQueryList".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/MediaQueryList Mozilla MediaQueryList documentation>
-newtype MediaQueryList = MediaQueryList { unMediaQueryList :: JSVal }
-
-instance Eq (MediaQueryList) where
-  (MediaQueryList a) == (MediaQueryList b) = js_eq a b
-
-instance PToJSVal MediaQueryList where
-  pToJSVal = unMediaQueryList
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal MediaQueryList where
-  pFromJSVal = MediaQueryList
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal MediaQueryList where
-  toJSVal = return . unMediaQueryList
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal MediaQueryList where
-  fromJSVal = return . fmap MediaQueryList . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject MediaQueryList where
-  toGObject = GObject . unMediaQueryList
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = MediaQueryList . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToMediaQueryList :: IsGObject obj => obj -> IO MediaQueryList
-castToMediaQueryList = castTo gTypeMediaQueryList "MediaQueryList"
-
-foreign import javascript unsafe "window[\"MediaQueryList\"]" gTypeMediaQueryList :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.MediaSource".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/MediaSource Mozilla MediaSource documentation>
-newtype MediaSource = MediaSource { unMediaSource :: JSVal }
-
-instance Eq (MediaSource) where
-  (MediaSource a) == (MediaSource b) = js_eq a b
-
-instance PToJSVal MediaSource where
-  pToJSVal = unMediaSource
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal MediaSource where
-  pFromJSVal = MediaSource
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal MediaSource where
-  toJSVal = return . unMediaSource
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal MediaSource where
-  fromJSVal = return . fmap MediaSource . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsEventTarget MediaSource
-instance IsGObject MediaSource where
-  toGObject = GObject . unMediaSource
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = MediaSource . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToMediaSource :: IsGObject obj => obj -> IO MediaSource
-castToMediaSource = castTo gTypeMediaSource "MediaSource"
-
-foreign import javascript unsafe "window[\"MediaSource\"]" gTypeMediaSource :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.MediaSourceStates".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/MediaSourceStates Mozilla MediaSourceStates documentation>
-newtype MediaSourceStates = MediaSourceStates { unMediaSourceStates :: JSVal }
-
-instance Eq (MediaSourceStates) where
-  (MediaSourceStates a) == (MediaSourceStates b) = js_eq a b
-
-instance PToJSVal MediaSourceStates where
-  pToJSVal = unMediaSourceStates
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal MediaSourceStates where
-  pFromJSVal = MediaSourceStates
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal MediaSourceStates where
-  toJSVal = return . unMediaSourceStates
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal MediaSourceStates where
-  fromJSVal = return . fmap MediaSourceStates . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject MediaSourceStates where
-  toGObject = GObject . unMediaSourceStates
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = MediaSourceStates . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToMediaSourceStates :: IsGObject obj => obj -> IO MediaSourceStates
-castToMediaSourceStates = castTo gTypeMediaSourceStates "MediaSourceStates"
-
-foreign import javascript unsafe "window[\"MediaSourceStates\"]" gTypeMediaSourceStates :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.MediaStream".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/webkitMediaStream Mozilla webkitMediaStream documentation>
-newtype MediaStream = MediaStream { unMediaStream :: JSVal }
-
-instance Eq (MediaStream) where
-  (MediaStream a) == (MediaStream b) = js_eq a b
-
-instance PToJSVal MediaStream where
-  pToJSVal = unMediaStream
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal MediaStream where
-  pFromJSVal = MediaStream
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal MediaStream where
-  toJSVal = return . unMediaStream
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal MediaStream where
-  fromJSVal = return . fmap MediaStream . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsEventTarget MediaStream
-instance IsGObject MediaStream where
-  toGObject = GObject . unMediaStream
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = MediaStream . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToMediaStream :: IsGObject obj => obj -> IO MediaStream
-castToMediaStream = castTo gTypeMediaStream "MediaStream"
-
-foreign import javascript unsafe "window[\"webkitMediaStream\"]" gTypeMediaStream :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.MediaStreamAudioDestinationNode".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.AudioNode"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/MediaStreamAudioDestinationNode Mozilla MediaStreamAudioDestinationNode documentation>
-newtype MediaStreamAudioDestinationNode = MediaStreamAudioDestinationNode { unMediaStreamAudioDestinationNode :: JSVal }
-
-instance Eq (MediaStreamAudioDestinationNode) where
-  (MediaStreamAudioDestinationNode a) == (MediaStreamAudioDestinationNode b) = js_eq a b
-
-instance PToJSVal MediaStreamAudioDestinationNode where
-  pToJSVal = unMediaStreamAudioDestinationNode
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal MediaStreamAudioDestinationNode where
-  pFromJSVal = MediaStreamAudioDestinationNode
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal MediaStreamAudioDestinationNode where
-  toJSVal = return . unMediaStreamAudioDestinationNode
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal MediaStreamAudioDestinationNode where
-  fromJSVal = return . fmap MediaStreamAudioDestinationNode . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsAudioNode MediaStreamAudioDestinationNode
-instance IsEventTarget MediaStreamAudioDestinationNode
-instance IsGObject MediaStreamAudioDestinationNode where
-  toGObject = GObject . unMediaStreamAudioDestinationNode
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = MediaStreamAudioDestinationNode . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToMediaStreamAudioDestinationNode :: IsGObject obj => obj -> IO MediaStreamAudioDestinationNode
-castToMediaStreamAudioDestinationNode = castTo gTypeMediaStreamAudioDestinationNode "MediaStreamAudioDestinationNode"
-
-foreign import javascript unsafe "window[\"MediaStreamAudioDestinationNode\"]" gTypeMediaStreamAudioDestinationNode :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.MediaStreamAudioSourceNode".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.AudioNode"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/MediaStreamAudioSourceNode Mozilla MediaStreamAudioSourceNode documentation>
-newtype MediaStreamAudioSourceNode = MediaStreamAudioSourceNode { unMediaStreamAudioSourceNode :: JSVal }
-
-instance Eq (MediaStreamAudioSourceNode) where
-  (MediaStreamAudioSourceNode a) == (MediaStreamAudioSourceNode b) = js_eq a b
-
-instance PToJSVal MediaStreamAudioSourceNode where
-  pToJSVal = unMediaStreamAudioSourceNode
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal MediaStreamAudioSourceNode where
-  pFromJSVal = MediaStreamAudioSourceNode
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal MediaStreamAudioSourceNode where
-  toJSVal = return . unMediaStreamAudioSourceNode
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal MediaStreamAudioSourceNode where
-  fromJSVal = return . fmap MediaStreamAudioSourceNode . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsAudioNode MediaStreamAudioSourceNode
-instance IsEventTarget MediaStreamAudioSourceNode
-instance IsGObject MediaStreamAudioSourceNode where
-  toGObject = GObject . unMediaStreamAudioSourceNode
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = MediaStreamAudioSourceNode . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToMediaStreamAudioSourceNode :: IsGObject obj => obj -> IO MediaStreamAudioSourceNode
-castToMediaStreamAudioSourceNode = castTo gTypeMediaStreamAudioSourceNode "MediaStreamAudioSourceNode"
-
-foreign import javascript unsafe "window[\"MediaStreamAudioSourceNode\"]" gTypeMediaStreamAudioSourceNode :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.MediaStreamCapabilities".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/MediaStreamCapabilities Mozilla MediaStreamCapabilities documentation>
-newtype MediaStreamCapabilities = MediaStreamCapabilities { unMediaStreamCapabilities :: JSVal }
-
-instance Eq (MediaStreamCapabilities) where
-  (MediaStreamCapabilities a) == (MediaStreamCapabilities b) = js_eq a b
-
-instance PToJSVal MediaStreamCapabilities where
-  pToJSVal = unMediaStreamCapabilities
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal MediaStreamCapabilities where
-  pFromJSVal = MediaStreamCapabilities
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal MediaStreamCapabilities where
-  toJSVal = return . unMediaStreamCapabilities
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal MediaStreamCapabilities where
-  fromJSVal = return . fmap MediaStreamCapabilities . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-class IsGObject o => IsMediaStreamCapabilities o
-toMediaStreamCapabilities :: IsMediaStreamCapabilities o => o -> MediaStreamCapabilities
-toMediaStreamCapabilities = unsafeCastGObject . toGObject
-
-instance IsMediaStreamCapabilities MediaStreamCapabilities
-instance IsGObject MediaStreamCapabilities where
-  toGObject = GObject . unMediaStreamCapabilities
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = MediaStreamCapabilities . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToMediaStreamCapabilities :: IsGObject obj => obj -> IO MediaStreamCapabilities
-castToMediaStreamCapabilities = castTo gTypeMediaStreamCapabilities "MediaStreamCapabilities"
-
-foreign import javascript unsafe "window[\"MediaStreamCapabilities\"]" gTypeMediaStreamCapabilities :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.MediaStreamEvent".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.Event"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/MediaStreamEvent Mozilla MediaStreamEvent documentation>
-newtype MediaStreamEvent = MediaStreamEvent { unMediaStreamEvent :: JSVal }
-
-instance Eq (MediaStreamEvent) where
-  (MediaStreamEvent a) == (MediaStreamEvent b) = js_eq a b
-
-instance PToJSVal MediaStreamEvent where
-  pToJSVal = unMediaStreamEvent
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal MediaStreamEvent where
-  pFromJSVal = MediaStreamEvent
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal MediaStreamEvent where
-  toJSVal = return . unMediaStreamEvent
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal MediaStreamEvent where
-  fromJSVal = return . fmap MediaStreamEvent . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsEvent MediaStreamEvent
-instance IsGObject MediaStreamEvent where
-  toGObject = GObject . unMediaStreamEvent
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = MediaStreamEvent . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToMediaStreamEvent :: IsGObject obj => obj -> IO MediaStreamEvent
-castToMediaStreamEvent = castTo gTypeMediaStreamEvent "MediaStreamEvent"
-
-foreign import javascript unsafe "window[\"MediaStreamEvent\"]" gTypeMediaStreamEvent :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.MediaStreamTrack".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/MediaStreamTrack Mozilla MediaStreamTrack documentation>
-newtype MediaStreamTrack = MediaStreamTrack { unMediaStreamTrack :: JSVal }
-
-instance Eq (MediaStreamTrack) where
-  (MediaStreamTrack a) == (MediaStreamTrack b) = js_eq a b
-
-instance PToJSVal MediaStreamTrack where
-  pToJSVal = unMediaStreamTrack
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal MediaStreamTrack where
-  pFromJSVal = MediaStreamTrack
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal MediaStreamTrack where
-  toJSVal = return . unMediaStreamTrack
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal MediaStreamTrack where
-  fromJSVal = return . fmap MediaStreamTrack . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-class IsEventTarget o => IsMediaStreamTrack o
-toMediaStreamTrack :: IsMediaStreamTrack o => o -> MediaStreamTrack
-toMediaStreamTrack = unsafeCastGObject . toGObject
-
-instance IsMediaStreamTrack MediaStreamTrack
-instance IsEventTarget MediaStreamTrack
-instance IsGObject MediaStreamTrack where
-  toGObject = GObject . unMediaStreamTrack
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = MediaStreamTrack . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToMediaStreamTrack :: IsGObject obj => obj -> IO MediaStreamTrack
-castToMediaStreamTrack = castTo gTypeMediaStreamTrack "MediaStreamTrack"
-
-foreign import javascript unsafe "window[\"MediaStreamTrack\"]" gTypeMediaStreamTrack :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.MediaStreamTrackEvent".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.Event"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/MediaStreamTrackEvent Mozilla MediaStreamTrackEvent documentation>
-newtype MediaStreamTrackEvent = MediaStreamTrackEvent { unMediaStreamTrackEvent :: JSVal }
-
-instance Eq (MediaStreamTrackEvent) where
-  (MediaStreamTrackEvent a) == (MediaStreamTrackEvent b) = js_eq a b
-
-instance PToJSVal MediaStreamTrackEvent where
-  pToJSVal = unMediaStreamTrackEvent
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal MediaStreamTrackEvent where
-  pFromJSVal = MediaStreamTrackEvent
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal MediaStreamTrackEvent where
-  toJSVal = return . unMediaStreamTrackEvent
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal MediaStreamTrackEvent where
-  fromJSVal = return . fmap MediaStreamTrackEvent . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsEvent MediaStreamTrackEvent
-instance IsGObject MediaStreamTrackEvent where
-  toGObject = GObject . unMediaStreamTrackEvent
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = MediaStreamTrackEvent . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToMediaStreamTrackEvent :: IsGObject obj => obj -> IO MediaStreamTrackEvent
-castToMediaStreamTrackEvent = castTo gTypeMediaStreamTrackEvent "MediaStreamTrackEvent"
-
-foreign import javascript unsafe "window[\"MediaStreamTrackEvent\"]" gTypeMediaStreamTrackEvent :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.MediaTrackConstraint".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/MediaTrackConstraint Mozilla MediaTrackConstraint documentation>
-newtype MediaTrackConstraint = MediaTrackConstraint { unMediaTrackConstraint :: JSVal }
-
-instance Eq (MediaTrackConstraint) where
-  (MediaTrackConstraint a) == (MediaTrackConstraint b) = js_eq a b
-
-instance PToJSVal MediaTrackConstraint where
-  pToJSVal = unMediaTrackConstraint
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal MediaTrackConstraint where
-  pFromJSVal = MediaTrackConstraint
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal MediaTrackConstraint where
-  toJSVal = return . unMediaTrackConstraint
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal MediaTrackConstraint where
-  fromJSVal = return . fmap MediaTrackConstraint . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject MediaTrackConstraint where
-  toGObject = GObject . unMediaTrackConstraint
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = MediaTrackConstraint . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToMediaTrackConstraint :: IsGObject obj => obj -> IO MediaTrackConstraint
-castToMediaTrackConstraint = castTo gTypeMediaTrackConstraint "MediaTrackConstraint"
-
-foreign import javascript unsafe "window[\"MediaTrackConstraint\"]" gTypeMediaTrackConstraint :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.MediaTrackConstraintSet".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/MediaTrackConstraintSet Mozilla MediaTrackConstraintSet documentation>
-newtype MediaTrackConstraintSet = MediaTrackConstraintSet { unMediaTrackConstraintSet :: JSVal }
-
-instance Eq (MediaTrackConstraintSet) where
-  (MediaTrackConstraintSet a) == (MediaTrackConstraintSet b) = js_eq a b
-
-instance PToJSVal MediaTrackConstraintSet where
-  pToJSVal = unMediaTrackConstraintSet
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal MediaTrackConstraintSet where
-  pFromJSVal = MediaTrackConstraintSet
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal MediaTrackConstraintSet where
-  toJSVal = return . unMediaTrackConstraintSet
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal MediaTrackConstraintSet where
-  fromJSVal = return . fmap MediaTrackConstraintSet . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject MediaTrackConstraintSet where
-  toGObject = GObject . unMediaTrackConstraintSet
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = MediaTrackConstraintSet . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToMediaTrackConstraintSet :: IsGObject obj => obj -> IO MediaTrackConstraintSet
-castToMediaTrackConstraintSet = castTo gTypeMediaTrackConstraintSet "MediaTrackConstraintSet"
-
-foreign import javascript unsafe "window[\"MediaTrackConstraintSet\"]" gTypeMediaTrackConstraintSet :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.MediaTrackConstraints".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/MediaTrackConstraints Mozilla MediaTrackConstraints documentation>
-newtype MediaTrackConstraints = MediaTrackConstraints { unMediaTrackConstraints :: JSVal }
-
-instance Eq (MediaTrackConstraints) where
-  (MediaTrackConstraints a) == (MediaTrackConstraints b) = js_eq a b
-
-instance PToJSVal MediaTrackConstraints where
-  pToJSVal = unMediaTrackConstraints
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal MediaTrackConstraints where
-  pFromJSVal = MediaTrackConstraints
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal MediaTrackConstraints where
-  toJSVal = return . unMediaTrackConstraints
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal MediaTrackConstraints where
-  fromJSVal = return . fmap MediaTrackConstraints . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject MediaTrackConstraints where
-  toGObject = GObject . unMediaTrackConstraints
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = MediaTrackConstraints . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToMediaTrackConstraints :: IsGObject obj => obj -> IO MediaTrackConstraints
-castToMediaTrackConstraints = castTo gTypeMediaTrackConstraints "MediaTrackConstraints"
-
-foreign import javascript unsafe "window[\"MediaTrackConstraints\"]" gTypeMediaTrackConstraints :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.MemoryInfo".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/MemoryInfo Mozilla MemoryInfo documentation>
-newtype MemoryInfo = MemoryInfo { unMemoryInfo :: JSVal }
-
-instance Eq (MemoryInfo) where
-  (MemoryInfo a) == (MemoryInfo b) = js_eq a b
-
-instance PToJSVal MemoryInfo where
-  pToJSVal = unMemoryInfo
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal MemoryInfo where
-  pFromJSVal = MemoryInfo
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal MemoryInfo where
-  toJSVal = return . unMemoryInfo
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal MemoryInfo where
-  fromJSVal = return . fmap MemoryInfo . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject MemoryInfo where
-  toGObject = GObject . unMemoryInfo
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = MemoryInfo . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToMemoryInfo :: IsGObject obj => obj -> IO MemoryInfo
-castToMemoryInfo = castTo gTypeMemoryInfo "MemoryInfo"
-
-foreign import javascript unsafe "window[\"MemoryInfo\"]" gTypeMemoryInfo :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.MessageChannel".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/MessageChannel Mozilla MessageChannel documentation>
-newtype MessageChannel = MessageChannel { unMessageChannel :: JSVal }
-
-instance Eq (MessageChannel) where
-  (MessageChannel a) == (MessageChannel b) = js_eq a b
-
-instance PToJSVal MessageChannel where
-  pToJSVal = unMessageChannel
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal MessageChannel where
-  pFromJSVal = MessageChannel
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal MessageChannel where
-  toJSVal = return . unMessageChannel
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal MessageChannel where
-  fromJSVal = return . fmap MessageChannel . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject MessageChannel where
-  toGObject = GObject . unMessageChannel
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = MessageChannel . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToMessageChannel :: IsGObject obj => obj -> IO MessageChannel
-castToMessageChannel = castTo gTypeMessageChannel "MessageChannel"
-
-foreign import javascript unsafe "window[\"MessageChannel\"]" gTypeMessageChannel :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.MessageEvent".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.Event"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/MessageEvent Mozilla MessageEvent documentation>
-newtype MessageEvent = MessageEvent { unMessageEvent :: JSVal }
-
-instance Eq (MessageEvent) where
-  (MessageEvent a) == (MessageEvent b) = js_eq a b
-
-instance PToJSVal MessageEvent where
-  pToJSVal = unMessageEvent
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal MessageEvent where
-  pFromJSVal = MessageEvent
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal MessageEvent where
-  toJSVal = return . unMessageEvent
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal MessageEvent where
-  fromJSVal = return . fmap MessageEvent . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsEvent MessageEvent
-instance IsGObject MessageEvent where
-  toGObject = GObject . unMessageEvent
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = MessageEvent . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToMessageEvent :: IsGObject obj => obj -> IO MessageEvent
-castToMessageEvent = castTo gTypeMessageEvent "MessageEvent"
-
-foreign import javascript unsafe "window[\"MessageEvent\"]" gTypeMessageEvent :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.MessagePort".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/MessagePort Mozilla MessagePort documentation>
-newtype MessagePort = MessagePort { unMessagePort :: JSVal }
-
-instance Eq (MessagePort) where
-  (MessagePort a) == (MessagePort b) = js_eq a b
-
-instance PToJSVal MessagePort where
-  pToJSVal = unMessagePort
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal MessagePort where
-  pFromJSVal = MessagePort
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal MessagePort where
-  toJSVal = return . unMessagePort
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal MessagePort where
-  fromJSVal = return . fmap MessagePort . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsEventTarget MessagePort
-instance IsGObject MessagePort where
-  toGObject = GObject . unMessagePort
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = MessagePort . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToMessagePort :: IsGObject obj => obj -> IO MessagePort
-castToMessagePort = castTo gTypeMessagePort "MessagePort"
-
-foreign import javascript unsafe "window[\"MessagePort\"]" gTypeMessagePort :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.MimeType".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/MimeType Mozilla MimeType documentation>
-newtype MimeType = MimeType { unMimeType :: JSVal }
-
-instance Eq (MimeType) where
-  (MimeType a) == (MimeType b) = js_eq a b
-
-instance PToJSVal MimeType where
-  pToJSVal = unMimeType
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal MimeType where
-  pFromJSVal = MimeType
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal MimeType where
-  toJSVal = return . unMimeType
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal MimeType where
-  fromJSVal = return . fmap MimeType . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject MimeType where
-  toGObject = GObject . unMimeType
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = MimeType . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToMimeType :: IsGObject obj => obj -> IO MimeType
-castToMimeType = castTo gTypeMimeType "MimeType"
-
-foreign import javascript unsafe "window[\"MimeType\"]" gTypeMimeType :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.MimeTypeArray".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/MimeTypeArray Mozilla MimeTypeArray documentation>
-newtype MimeTypeArray = MimeTypeArray { unMimeTypeArray :: JSVal }
-
-instance Eq (MimeTypeArray) where
-  (MimeTypeArray a) == (MimeTypeArray b) = js_eq a b
-
-instance PToJSVal MimeTypeArray where
-  pToJSVal = unMimeTypeArray
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal MimeTypeArray where
-  pFromJSVal = MimeTypeArray
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal MimeTypeArray where
-  toJSVal = return . unMimeTypeArray
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal MimeTypeArray where
-  fromJSVal = return . fmap MimeTypeArray . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject MimeTypeArray where
-  toGObject = GObject . unMimeTypeArray
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = MimeTypeArray . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToMimeTypeArray :: IsGObject obj => obj -> IO MimeTypeArray
-castToMimeTypeArray = castTo gTypeMimeTypeArray "MimeTypeArray"
-
-foreign import javascript unsafe "window[\"MimeTypeArray\"]" gTypeMimeTypeArray :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.MouseEvent".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.UIEvent"
---     * "GHCJS.DOM.Event"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/MouseEvent Mozilla MouseEvent documentation>
-newtype MouseEvent = MouseEvent { unMouseEvent :: JSVal }
-
-instance Eq (MouseEvent) where
-  (MouseEvent a) == (MouseEvent b) = js_eq a b
-
-instance PToJSVal MouseEvent where
-  pToJSVal = unMouseEvent
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal MouseEvent where
-  pFromJSVal = MouseEvent
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal MouseEvent where
-  toJSVal = return . unMouseEvent
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal MouseEvent where
-  fromJSVal = return . fmap MouseEvent . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-class IsUIEvent o => IsMouseEvent o
-toMouseEvent :: IsMouseEvent o => o -> MouseEvent
-toMouseEvent = unsafeCastGObject . toGObject
-
-instance IsMouseEvent MouseEvent
-instance IsUIEvent MouseEvent
-instance IsEvent MouseEvent
-instance IsGObject MouseEvent where
-  toGObject = GObject . unMouseEvent
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = MouseEvent . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToMouseEvent :: IsGObject obj => obj -> IO MouseEvent
-castToMouseEvent = castTo gTypeMouseEvent "MouseEvent"
-
-foreign import javascript unsafe "window[\"MouseEvent\"]" gTypeMouseEvent :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.MutationEvent".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.Event"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/MutationEvent Mozilla MutationEvent documentation>
-newtype MutationEvent = MutationEvent { unMutationEvent :: JSVal }
-
-instance Eq (MutationEvent) where
-  (MutationEvent a) == (MutationEvent b) = js_eq a b
-
-instance PToJSVal MutationEvent where
-  pToJSVal = unMutationEvent
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal MutationEvent where
-  pFromJSVal = MutationEvent
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal MutationEvent where
-  toJSVal = return . unMutationEvent
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal MutationEvent where
-  fromJSVal = return . fmap MutationEvent . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsEvent MutationEvent
-instance IsGObject MutationEvent where
-  toGObject = GObject . unMutationEvent
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = MutationEvent . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToMutationEvent :: IsGObject obj => obj -> IO MutationEvent
-castToMutationEvent = castTo gTypeMutationEvent "MutationEvent"
-
-foreign import javascript unsafe "window[\"MutationEvent\"]" gTypeMutationEvent :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.MutationObserver".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/MutationObserver Mozilla MutationObserver documentation>
-newtype MutationObserver = MutationObserver { unMutationObserver :: JSVal }
-
-instance Eq (MutationObserver) where
-  (MutationObserver a) == (MutationObserver b) = js_eq a b
-
-instance PToJSVal MutationObserver where
-  pToJSVal = unMutationObserver
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal MutationObserver where
-  pFromJSVal = MutationObserver
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal MutationObserver where
-  toJSVal = return . unMutationObserver
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal MutationObserver where
-  fromJSVal = return . fmap MutationObserver . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject MutationObserver where
-  toGObject = GObject . unMutationObserver
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = MutationObserver . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToMutationObserver :: IsGObject obj => obj -> IO MutationObserver
-castToMutationObserver = castTo gTypeMutationObserver "MutationObserver"
-
-foreign import javascript unsafe "window[\"MutationObserver\"]" gTypeMutationObserver :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.MutationRecord".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/MutationRecord Mozilla MutationRecord documentation>
-newtype MutationRecord = MutationRecord { unMutationRecord :: JSVal }
-
-instance Eq (MutationRecord) where
-  (MutationRecord a) == (MutationRecord b) = js_eq a b
-
-instance PToJSVal MutationRecord where
-  pToJSVal = unMutationRecord
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal MutationRecord where
-  pFromJSVal = MutationRecord
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal MutationRecord where
-  toJSVal = return . unMutationRecord
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal MutationRecord where
-  fromJSVal = return . fmap MutationRecord . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject MutationRecord where
-  toGObject = GObject . unMutationRecord
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = MutationRecord . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToMutationRecord :: IsGObject obj => obj -> IO MutationRecord
-castToMutationRecord = castTo gTypeMutationRecord "MutationRecord"
-
-foreign import javascript unsafe "window[\"MutationRecord\"]" gTypeMutationRecord :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.NamedNodeMap".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/NamedNodeMap Mozilla NamedNodeMap documentation>
-newtype NamedNodeMap = NamedNodeMap { unNamedNodeMap :: JSVal }
-
-instance Eq (NamedNodeMap) where
-  (NamedNodeMap a) == (NamedNodeMap b) = js_eq a b
-
-instance PToJSVal NamedNodeMap where
-  pToJSVal = unNamedNodeMap
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal NamedNodeMap where
-  pFromJSVal = NamedNodeMap
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal NamedNodeMap where
-  toJSVal = return . unNamedNodeMap
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal NamedNodeMap where
-  fromJSVal = return . fmap NamedNodeMap . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject NamedNodeMap where
-  toGObject = GObject . unNamedNodeMap
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = NamedNodeMap . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToNamedNodeMap :: IsGObject obj => obj -> IO NamedNodeMap
-castToNamedNodeMap = castTo gTypeNamedNodeMap "NamedNodeMap"
-
-foreign import javascript unsafe "window[\"NamedNodeMap\"]" gTypeNamedNodeMap :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.Navigator".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/Navigator Mozilla Navigator documentation>
-newtype Navigator = Navigator { unNavigator :: JSVal }
-
-instance Eq (Navigator) where
-  (Navigator a) == (Navigator b) = js_eq a b
-
-instance PToJSVal Navigator where
-  pToJSVal = unNavigator
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal Navigator where
-  pFromJSVal = Navigator
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal Navigator where
-  toJSVal = return . unNavigator
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal Navigator where
-  fromJSVal = return . fmap Navigator . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject Navigator where
-  toGObject = GObject . unNavigator
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = Navigator . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToNavigator :: IsGObject obj => obj -> IO Navigator
-castToNavigator = castTo gTypeNavigator "Navigator"
-
-foreign import javascript unsafe "window[\"Navigator\"]" gTypeNavigator :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.NavigatorUserMediaError".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.DOMError"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/NavigatorUserMediaError Mozilla NavigatorUserMediaError documentation>
-newtype NavigatorUserMediaError = NavigatorUserMediaError { unNavigatorUserMediaError :: JSVal }
-
-instance Eq (NavigatorUserMediaError) where
-  (NavigatorUserMediaError a) == (NavigatorUserMediaError b) = js_eq a b
-
-instance PToJSVal NavigatorUserMediaError where
-  pToJSVal = unNavigatorUserMediaError
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal NavigatorUserMediaError where
-  pFromJSVal = NavigatorUserMediaError
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal NavigatorUserMediaError where
-  toJSVal = return . unNavigatorUserMediaError
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal NavigatorUserMediaError where
-  fromJSVal = return . fmap NavigatorUserMediaError . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsDOMError NavigatorUserMediaError
-instance IsGObject NavigatorUserMediaError where
-  toGObject = GObject . unNavigatorUserMediaError
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = NavigatorUserMediaError . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToNavigatorUserMediaError :: IsGObject obj => obj -> IO NavigatorUserMediaError
-castToNavigatorUserMediaError = castTo gTypeNavigatorUserMediaError "NavigatorUserMediaError"
-
-foreign import javascript unsafe "window[\"NavigatorUserMediaError\"]" gTypeNavigatorUserMediaError :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.Node".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/Node Mozilla Node documentation>
-newtype Node = Node { unNode :: JSVal }
-
-instance Eq (Node) where
-  (Node a) == (Node b) = js_eq a b
-
-instance PToJSVal Node where
-  pToJSVal = unNode
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal Node where
-  pFromJSVal = Node
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal Node where
-  toJSVal = return . unNode
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal Node where
-  fromJSVal = return . fmap Node . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-class IsEventTarget o => IsNode o
-toNode :: IsNode o => o -> Node
-toNode = unsafeCastGObject . toGObject
-
-instance IsNode Node
-instance IsEventTarget Node
-instance IsGObject Node where
-  toGObject = GObject . unNode
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = Node . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToNode :: IsGObject obj => obj -> IO Node
-castToNode = castTo gTypeNode "Node"
-
-foreign import javascript unsafe "window[\"Node\"]" gTypeNode :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.NodeFilter".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/NodeFilter Mozilla NodeFilter documentation>
-newtype NodeFilter = NodeFilter { unNodeFilter :: JSVal }
-
-instance Eq (NodeFilter) where
-  (NodeFilter a) == (NodeFilter b) = js_eq a b
-
-instance PToJSVal NodeFilter where
-  pToJSVal = unNodeFilter
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal NodeFilter where
-  pFromJSVal = NodeFilter
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal NodeFilter where
-  toJSVal = return . unNodeFilter
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal NodeFilter where
-  fromJSVal = return . fmap NodeFilter . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject NodeFilter where
-  toGObject = GObject . unNodeFilter
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = NodeFilter . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToNodeFilter :: IsGObject obj => obj -> IO NodeFilter
-castToNodeFilter = castTo gTypeNodeFilter "NodeFilter"
-
-foreign import javascript unsafe "window[\"NodeFilter\"]" gTypeNodeFilter :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.NodeIterator".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/NodeIterator Mozilla NodeIterator documentation>
-newtype NodeIterator = NodeIterator { unNodeIterator :: JSVal }
-
-instance Eq (NodeIterator) where
-  (NodeIterator a) == (NodeIterator b) = js_eq a b
-
-instance PToJSVal NodeIterator where
-  pToJSVal = unNodeIterator
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal NodeIterator where
-  pFromJSVal = NodeIterator
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal NodeIterator where
-  toJSVal = return . unNodeIterator
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal NodeIterator where
-  fromJSVal = return . fmap NodeIterator . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject NodeIterator where
-  toGObject = GObject . unNodeIterator
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = NodeIterator . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToNodeIterator :: IsGObject obj => obj -> IO NodeIterator
-castToNodeIterator = castTo gTypeNodeIterator "NodeIterator"
-
-foreign import javascript unsafe "window[\"NodeIterator\"]" gTypeNodeIterator :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.NodeList".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/NodeList Mozilla NodeList documentation>
-newtype NodeList = NodeList { unNodeList :: JSVal }
-
-instance Eq (NodeList) where
-  (NodeList a) == (NodeList b) = js_eq a b
-
-instance PToJSVal NodeList where
-  pToJSVal = unNodeList
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal NodeList where
-  pFromJSVal = NodeList
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal NodeList where
-  toJSVal = return . unNodeList
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal NodeList where
-  fromJSVal = return . fmap NodeList . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-class IsGObject o => IsNodeList o
-toNodeList :: IsNodeList o => o -> NodeList
-toNodeList = unsafeCastGObject . toGObject
-
-instance IsNodeList NodeList
-instance IsGObject NodeList where
-  toGObject = GObject . unNodeList
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = NodeList . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToNodeList :: IsGObject obj => obj -> IO NodeList
-castToNodeList = castTo gTypeNodeList "NodeList"
-
-foreign import javascript unsafe "window[\"NodeList\"]" gTypeNodeList :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.Notification".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/Notification Mozilla Notification documentation>
-newtype Notification = Notification { unNotification :: JSVal }
-
-instance Eq (Notification) where
-  (Notification a) == (Notification b) = js_eq a b
-
-instance PToJSVal Notification where
-  pToJSVal = unNotification
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal Notification where
-  pFromJSVal = Notification
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal Notification where
-  toJSVal = return . unNotification
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal Notification where
-  fromJSVal = return . fmap Notification . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsEventTarget Notification
-instance IsGObject Notification where
-  toGObject = GObject . unNotification
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = Notification . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToNotification :: IsGObject obj => obj -> IO Notification
-castToNotification = castTo gTypeNotification "Notification"
-
-foreign import javascript unsafe "window[\"Notification\"]" gTypeNotification :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.NotificationCenter".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/NotificationCenter Mozilla NotificationCenter documentation>
-newtype NotificationCenter = NotificationCenter { unNotificationCenter :: JSVal }
-
-instance Eq (NotificationCenter) where
-  (NotificationCenter a) == (NotificationCenter b) = js_eq a b
-
-instance PToJSVal NotificationCenter where
-  pToJSVal = unNotificationCenter
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal NotificationCenter where
-  pFromJSVal = NotificationCenter
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal NotificationCenter where
-  toJSVal = return . unNotificationCenter
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal NotificationCenter where
-  fromJSVal = return . fmap NotificationCenter . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject NotificationCenter where
-  toGObject = GObject . unNotificationCenter
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = NotificationCenter . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToNotificationCenter :: IsGObject obj => obj -> IO NotificationCenter
-castToNotificationCenter = castTo gTypeNotificationCenter "NotificationCenter"
-
-foreign import javascript unsafe "window[\"NotificationCenter\"]" gTypeNotificationCenter :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.OESElementIndexUint".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/OESElementIndexUint Mozilla OESElementIndexUint documentation>
-newtype OESElementIndexUint = OESElementIndexUint { unOESElementIndexUint :: JSVal }
-
-instance Eq (OESElementIndexUint) where
-  (OESElementIndexUint a) == (OESElementIndexUint b) = js_eq a b
-
-instance PToJSVal OESElementIndexUint where
-  pToJSVal = unOESElementIndexUint
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal OESElementIndexUint where
-  pFromJSVal = OESElementIndexUint
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal OESElementIndexUint where
-  toJSVal = return . unOESElementIndexUint
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal OESElementIndexUint where
-  fromJSVal = return . fmap OESElementIndexUint . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject OESElementIndexUint where
-  toGObject = GObject . unOESElementIndexUint
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = OESElementIndexUint . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToOESElementIndexUint :: IsGObject obj => obj -> IO OESElementIndexUint
-castToOESElementIndexUint = castTo gTypeOESElementIndexUint "OESElementIndexUint"
-
-foreign import javascript unsafe "window[\"OESElementIndexUint\"]" gTypeOESElementIndexUint :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.OESStandardDerivatives".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/OESStandardDerivatives Mozilla OESStandardDerivatives documentation>
-newtype OESStandardDerivatives = OESStandardDerivatives { unOESStandardDerivatives :: JSVal }
-
-instance Eq (OESStandardDerivatives) where
-  (OESStandardDerivatives a) == (OESStandardDerivatives b) = js_eq a b
-
-instance PToJSVal OESStandardDerivatives where
-  pToJSVal = unOESStandardDerivatives
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal OESStandardDerivatives where
-  pFromJSVal = OESStandardDerivatives
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal OESStandardDerivatives where
-  toJSVal = return . unOESStandardDerivatives
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal OESStandardDerivatives where
-  fromJSVal = return . fmap OESStandardDerivatives . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject OESStandardDerivatives where
-  toGObject = GObject . unOESStandardDerivatives
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = OESStandardDerivatives . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToOESStandardDerivatives :: IsGObject obj => obj -> IO OESStandardDerivatives
-castToOESStandardDerivatives = castTo gTypeOESStandardDerivatives "OESStandardDerivatives"
-
-foreign import javascript unsafe "window[\"OESStandardDerivatives\"]" gTypeOESStandardDerivatives :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.OESTextureFloat".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/OESTextureFloat Mozilla OESTextureFloat documentation>
-newtype OESTextureFloat = OESTextureFloat { unOESTextureFloat :: JSVal }
-
-instance Eq (OESTextureFloat) where
-  (OESTextureFloat a) == (OESTextureFloat b) = js_eq a b
-
-instance PToJSVal OESTextureFloat where
-  pToJSVal = unOESTextureFloat
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal OESTextureFloat where
-  pFromJSVal = OESTextureFloat
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal OESTextureFloat where
-  toJSVal = return . unOESTextureFloat
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal OESTextureFloat where
-  fromJSVal = return . fmap OESTextureFloat . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject OESTextureFloat where
-  toGObject = GObject . unOESTextureFloat
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = OESTextureFloat . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToOESTextureFloat :: IsGObject obj => obj -> IO OESTextureFloat
-castToOESTextureFloat = castTo gTypeOESTextureFloat "OESTextureFloat"
-
-foreign import javascript unsafe "window[\"OESTextureFloat\"]" gTypeOESTextureFloat :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.OESTextureFloatLinear".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/OESTextureFloatLinear Mozilla OESTextureFloatLinear documentation>
-newtype OESTextureFloatLinear = OESTextureFloatLinear { unOESTextureFloatLinear :: JSVal }
-
-instance Eq (OESTextureFloatLinear) where
-  (OESTextureFloatLinear a) == (OESTextureFloatLinear b) = js_eq a b
-
-instance PToJSVal OESTextureFloatLinear where
-  pToJSVal = unOESTextureFloatLinear
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal OESTextureFloatLinear where
-  pFromJSVal = OESTextureFloatLinear
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal OESTextureFloatLinear where
-  toJSVal = return . unOESTextureFloatLinear
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal OESTextureFloatLinear where
-  fromJSVal = return . fmap OESTextureFloatLinear . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject OESTextureFloatLinear where
-  toGObject = GObject . unOESTextureFloatLinear
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = OESTextureFloatLinear . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToOESTextureFloatLinear :: IsGObject obj => obj -> IO OESTextureFloatLinear
-castToOESTextureFloatLinear = castTo gTypeOESTextureFloatLinear "OESTextureFloatLinear"
-
-foreign import javascript unsafe "window[\"OESTextureFloatLinear\"]" gTypeOESTextureFloatLinear :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.OESTextureHalfFloat".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/OESTextureHalfFloat Mozilla OESTextureHalfFloat documentation>
-newtype OESTextureHalfFloat = OESTextureHalfFloat { unOESTextureHalfFloat :: JSVal }
-
-instance Eq (OESTextureHalfFloat) where
-  (OESTextureHalfFloat a) == (OESTextureHalfFloat b) = js_eq a b
-
-instance PToJSVal OESTextureHalfFloat where
-  pToJSVal = unOESTextureHalfFloat
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal OESTextureHalfFloat where
-  pFromJSVal = OESTextureHalfFloat
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal OESTextureHalfFloat where
-  toJSVal = return . unOESTextureHalfFloat
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal OESTextureHalfFloat where
-  fromJSVal = return . fmap OESTextureHalfFloat . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject OESTextureHalfFloat where
-  toGObject = GObject . unOESTextureHalfFloat
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = OESTextureHalfFloat . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToOESTextureHalfFloat :: IsGObject obj => obj -> IO OESTextureHalfFloat
-castToOESTextureHalfFloat = castTo gTypeOESTextureHalfFloat "OESTextureHalfFloat"
-
-foreign import javascript unsafe "window[\"OESTextureHalfFloat\"]" gTypeOESTextureHalfFloat :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.OESTextureHalfFloatLinear".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/OESTextureHalfFloatLinear Mozilla OESTextureHalfFloatLinear documentation>
-newtype OESTextureHalfFloatLinear = OESTextureHalfFloatLinear { unOESTextureHalfFloatLinear :: JSVal }
-
-instance Eq (OESTextureHalfFloatLinear) where
-  (OESTextureHalfFloatLinear a) == (OESTextureHalfFloatLinear b) = js_eq a b
-
-instance PToJSVal OESTextureHalfFloatLinear where
-  pToJSVal = unOESTextureHalfFloatLinear
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal OESTextureHalfFloatLinear where
-  pFromJSVal = OESTextureHalfFloatLinear
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal OESTextureHalfFloatLinear where
-  toJSVal = return . unOESTextureHalfFloatLinear
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal OESTextureHalfFloatLinear where
-  fromJSVal = return . fmap OESTextureHalfFloatLinear . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject OESTextureHalfFloatLinear where
-  toGObject = GObject . unOESTextureHalfFloatLinear
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = OESTextureHalfFloatLinear . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToOESTextureHalfFloatLinear :: IsGObject obj => obj -> IO OESTextureHalfFloatLinear
-castToOESTextureHalfFloatLinear = castTo gTypeOESTextureHalfFloatLinear "OESTextureHalfFloatLinear"
-
-foreign import javascript unsafe "window[\"OESTextureHalfFloatLinear\"]" gTypeOESTextureHalfFloatLinear :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.OESVertexArrayObject".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/OESVertexArrayObject Mozilla OESVertexArrayObject documentation>
-newtype OESVertexArrayObject = OESVertexArrayObject { unOESVertexArrayObject :: JSVal }
-
-instance Eq (OESVertexArrayObject) where
-  (OESVertexArrayObject a) == (OESVertexArrayObject b) = js_eq a b
-
-instance PToJSVal OESVertexArrayObject where
-  pToJSVal = unOESVertexArrayObject
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal OESVertexArrayObject where
-  pFromJSVal = OESVertexArrayObject
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal OESVertexArrayObject where
-  toJSVal = return . unOESVertexArrayObject
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal OESVertexArrayObject where
-  fromJSVal = return . fmap OESVertexArrayObject . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject OESVertexArrayObject where
-  toGObject = GObject . unOESVertexArrayObject
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = OESVertexArrayObject . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToOESVertexArrayObject :: IsGObject obj => obj -> IO OESVertexArrayObject
-castToOESVertexArrayObject = castTo gTypeOESVertexArrayObject "OESVertexArrayObject"
-
-foreign import javascript unsafe "window[\"OESVertexArrayObject\"]" gTypeOESVertexArrayObject :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.OfflineAudioCompletionEvent".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.Event"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/OfflineAudioCompletionEvent Mozilla OfflineAudioCompletionEvent documentation>
-newtype OfflineAudioCompletionEvent = OfflineAudioCompletionEvent { unOfflineAudioCompletionEvent :: JSVal }
-
-instance Eq (OfflineAudioCompletionEvent) where
-  (OfflineAudioCompletionEvent a) == (OfflineAudioCompletionEvent b) = js_eq a b
-
-instance PToJSVal OfflineAudioCompletionEvent where
-  pToJSVal = unOfflineAudioCompletionEvent
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal OfflineAudioCompletionEvent where
-  pFromJSVal = OfflineAudioCompletionEvent
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal OfflineAudioCompletionEvent where
-  toJSVal = return . unOfflineAudioCompletionEvent
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal OfflineAudioCompletionEvent where
-  fromJSVal = return . fmap OfflineAudioCompletionEvent . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsEvent OfflineAudioCompletionEvent
-instance IsGObject OfflineAudioCompletionEvent where
-  toGObject = GObject . unOfflineAudioCompletionEvent
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = OfflineAudioCompletionEvent . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToOfflineAudioCompletionEvent :: IsGObject obj => obj -> IO OfflineAudioCompletionEvent
-castToOfflineAudioCompletionEvent = castTo gTypeOfflineAudioCompletionEvent "OfflineAudioCompletionEvent"
-
-foreign import javascript unsafe "window[\"OfflineAudioCompletionEvent\"]" gTypeOfflineAudioCompletionEvent :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.OfflineAudioContext".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.AudioContext"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/OfflineAudioContext Mozilla OfflineAudioContext documentation>
-newtype OfflineAudioContext = OfflineAudioContext { unOfflineAudioContext :: JSVal }
-
-instance Eq (OfflineAudioContext) where
-  (OfflineAudioContext a) == (OfflineAudioContext b) = js_eq a b
-
-instance PToJSVal OfflineAudioContext where
-  pToJSVal = unOfflineAudioContext
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal OfflineAudioContext where
-  pFromJSVal = OfflineAudioContext
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal OfflineAudioContext where
-  toJSVal = return . unOfflineAudioContext
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal OfflineAudioContext where
-  fromJSVal = return . fmap OfflineAudioContext . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsAudioContext OfflineAudioContext
-instance IsEventTarget OfflineAudioContext
-instance IsGObject OfflineAudioContext where
-  toGObject = GObject . unOfflineAudioContext
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = OfflineAudioContext . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToOfflineAudioContext :: IsGObject obj => obj -> IO OfflineAudioContext
-castToOfflineAudioContext = castTo gTypeOfflineAudioContext "OfflineAudioContext"
-
-foreign import javascript unsafe "window[\"OfflineAudioContext\"]" gTypeOfflineAudioContext :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.OscillatorNode".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.AudioNode"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/OscillatorNode Mozilla OscillatorNode documentation>
-newtype OscillatorNode = OscillatorNode { unOscillatorNode :: JSVal }
-
-instance Eq (OscillatorNode) where
-  (OscillatorNode a) == (OscillatorNode b) = js_eq a b
-
-instance PToJSVal OscillatorNode where
-  pToJSVal = unOscillatorNode
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal OscillatorNode where
-  pFromJSVal = OscillatorNode
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal OscillatorNode where
-  toJSVal = return . unOscillatorNode
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal OscillatorNode where
-  fromJSVal = return . fmap OscillatorNode . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsAudioNode OscillatorNode
-instance IsEventTarget OscillatorNode
-instance IsGObject OscillatorNode where
-  toGObject = GObject . unOscillatorNode
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = OscillatorNode . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToOscillatorNode :: IsGObject obj => obj -> IO OscillatorNode
-castToOscillatorNode = castTo gTypeOscillatorNode "OscillatorNode"
-
-foreign import javascript unsafe "window[\"OscillatorNode\"]" gTypeOscillatorNode :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.OverflowEvent".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.Event"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/OverflowEvent Mozilla OverflowEvent documentation>
-newtype OverflowEvent = OverflowEvent { unOverflowEvent :: JSVal }
-
-instance Eq (OverflowEvent) where
-  (OverflowEvent a) == (OverflowEvent b) = js_eq a b
-
-instance PToJSVal OverflowEvent where
-  pToJSVal = unOverflowEvent
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal OverflowEvent where
-  pFromJSVal = OverflowEvent
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal OverflowEvent where
-  toJSVal = return . unOverflowEvent
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal OverflowEvent where
-  fromJSVal = return . fmap OverflowEvent . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsEvent OverflowEvent
-instance IsGObject OverflowEvent where
-  toGObject = GObject . unOverflowEvent
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = OverflowEvent . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToOverflowEvent :: IsGObject obj => obj -> IO OverflowEvent
-castToOverflowEvent = castTo gTypeOverflowEvent "OverflowEvent"
-
-foreign import javascript unsafe "window[\"OverflowEvent\"]" gTypeOverflowEvent :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.PageTransitionEvent".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.Event"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/PageTransitionEvent Mozilla PageTransitionEvent documentation>
-newtype PageTransitionEvent = PageTransitionEvent { unPageTransitionEvent :: JSVal }
-
-instance Eq (PageTransitionEvent) where
-  (PageTransitionEvent a) == (PageTransitionEvent b) = js_eq a b
-
-instance PToJSVal PageTransitionEvent where
-  pToJSVal = unPageTransitionEvent
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal PageTransitionEvent where
-  pFromJSVal = PageTransitionEvent
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal PageTransitionEvent where
-  toJSVal = return . unPageTransitionEvent
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal PageTransitionEvent where
-  fromJSVal = return . fmap PageTransitionEvent . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsEvent PageTransitionEvent
-instance IsGObject PageTransitionEvent where
-  toGObject = GObject . unPageTransitionEvent
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = PageTransitionEvent . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToPageTransitionEvent :: IsGObject obj => obj -> IO PageTransitionEvent
-castToPageTransitionEvent = castTo gTypePageTransitionEvent "PageTransitionEvent"
-
-foreign import javascript unsafe "window[\"PageTransitionEvent\"]" gTypePageTransitionEvent :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.PannerNode".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.AudioNode"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/webkitAudioPannerNode Mozilla webkitAudioPannerNode documentation>
-newtype PannerNode = PannerNode { unPannerNode :: JSVal }
-
-instance Eq (PannerNode) where
-  (PannerNode a) == (PannerNode b) = js_eq a b
-
-instance PToJSVal PannerNode where
-  pToJSVal = unPannerNode
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal PannerNode where
-  pFromJSVal = PannerNode
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal PannerNode where
-  toJSVal = return . unPannerNode
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal PannerNode where
-  fromJSVal = return . fmap PannerNode . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsAudioNode PannerNode
-instance IsEventTarget PannerNode
-instance IsGObject PannerNode where
-  toGObject = GObject . unPannerNode
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = PannerNode . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToPannerNode :: IsGObject obj => obj -> IO PannerNode
-castToPannerNode = castTo gTypePannerNode "PannerNode"
-
-foreign import javascript unsafe "window[\"webkitAudioPannerNode\"]" gTypePannerNode :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.Path2D".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/Path2D Mozilla Path2D documentation>
-newtype Path2D = Path2D { unPath2D :: JSVal }
-
-instance Eq (Path2D) where
-  (Path2D a) == (Path2D b) = js_eq a b
-
-instance PToJSVal Path2D where
-  pToJSVal = unPath2D
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal Path2D where
-  pFromJSVal = Path2D
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal Path2D where
-  toJSVal = return . unPath2D
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal Path2D where
-  fromJSVal = return . fmap Path2D . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject Path2D where
-  toGObject = GObject . unPath2D
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = Path2D . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToPath2D :: IsGObject obj => obj -> IO Path2D
-castToPath2D = castTo gTypePath2D "Path2D"
-
-foreign import javascript unsafe "window[\"Path2D\"]" gTypePath2D :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.Performance".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/Performance Mozilla Performance documentation>
-newtype Performance = Performance { unPerformance :: JSVal }
-
-instance Eq (Performance) where
-  (Performance a) == (Performance b) = js_eq a b
-
-instance PToJSVal Performance where
-  pToJSVal = unPerformance
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal Performance where
-  pFromJSVal = Performance
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal Performance where
-  toJSVal = return . unPerformance
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal Performance where
-  fromJSVal = return . fmap Performance . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsEventTarget Performance
-instance IsGObject Performance where
-  toGObject = GObject . unPerformance
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = Performance . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToPerformance :: IsGObject obj => obj -> IO Performance
-castToPerformance = castTo gTypePerformance "Performance"
-
-foreign import javascript unsafe "window[\"Performance\"]" gTypePerformance :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.PerformanceEntry".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/PerformanceEntry Mozilla PerformanceEntry documentation>
-newtype PerformanceEntry = PerformanceEntry { unPerformanceEntry :: JSVal }
-
-instance Eq (PerformanceEntry) where
-  (PerformanceEntry a) == (PerformanceEntry b) = js_eq a b
-
-instance PToJSVal PerformanceEntry where
-  pToJSVal = unPerformanceEntry
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal PerformanceEntry where
-  pFromJSVal = PerformanceEntry
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal PerformanceEntry where
-  toJSVal = return . unPerformanceEntry
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal PerformanceEntry where
-  fromJSVal = return . fmap PerformanceEntry . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-class IsGObject o => IsPerformanceEntry o
-toPerformanceEntry :: IsPerformanceEntry o => o -> PerformanceEntry
-toPerformanceEntry = unsafeCastGObject . toGObject
-
-instance IsPerformanceEntry PerformanceEntry
-instance IsGObject PerformanceEntry where
-  toGObject = GObject . unPerformanceEntry
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = PerformanceEntry . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToPerformanceEntry :: IsGObject obj => obj -> IO PerformanceEntry
-castToPerformanceEntry = castTo gTypePerformanceEntry "PerformanceEntry"
-
-foreign import javascript unsafe "window[\"PerformanceEntry\"]" gTypePerformanceEntry :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.PerformanceEntryList".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/PerformanceEntryList Mozilla PerformanceEntryList documentation>
-newtype PerformanceEntryList = PerformanceEntryList { unPerformanceEntryList :: JSVal }
-
-instance Eq (PerformanceEntryList) where
-  (PerformanceEntryList a) == (PerformanceEntryList b) = js_eq a b
-
-instance PToJSVal PerformanceEntryList where
-  pToJSVal = unPerformanceEntryList
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal PerformanceEntryList where
-  pFromJSVal = PerformanceEntryList
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal PerformanceEntryList where
-  toJSVal = return . unPerformanceEntryList
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal PerformanceEntryList where
-  fromJSVal = return . fmap PerformanceEntryList . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject PerformanceEntryList where
-  toGObject = GObject . unPerformanceEntryList
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = PerformanceEntryList . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToPerformanceEntryList :: IsGObject obj => obj -> IO PerformanceEntryList
-castToPerformanceEntryList = castTo gTypePerformanceEntryList "PerformanceEntryList"
-
-foreign import javascript unsafe "window[\"PerformanceEntryList\"]" gTypePerformanceEntryList :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.PerformanceMark".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.PerformanceEntry"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/PerformanceMark Mozilla PerformanceMark documentation>
-newtype PerformanceMark = PerformanceMark { unPerformanceMark :: JSVal }
-
-instance Eq (PerformanceMark) where
-  (PerformanceMark a) == (PerformanceMark b) = js_eq a b
-
-instance PToJSVal PerformanceMark where
-  pToJSVal = unPerformanceMark
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal PerformanceMark where
-  pFromJSVal = PerformanceMark
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal PerformanceMark where
-  toJSVal = return . unPerformanceMark
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal PerformanceMark where
-  fromJSVal = return . fmap PerformanceMark . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsPerformanceEntry PerformanceMark
-instance IsGObject PerformanceMark where
-  toGObject = GObject . unPerformanceMark
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = PerformanceMark . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToPerformanceMark :: IsGObject obj => obj -> IO PerformanceMark
-castToPerformanceMark = castTo gTypePerformanceMark "PerformanceMark"
-
-foreign import javascript unsafe "window[\"PerformanceMark\"]" gTypePerformanceMark :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.PerformanceMeasure".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.PerformanceEntry"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/PerformanceMeasure Mozilla PerformanceMeasure documentation>
-newtype PerformanceMeasure = PerformanceMeasure { unPerformanceMeasure :: JSVal }
-
-instance Eq (PerformanceMeasure) where
-  (PerformanceMeasure a) == (PerformanceMeasure b) = js_eq a b
-
-instance PToJSVal PerformanceMeasure where
-  pToJSVal = unPerformanceMeasure
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal PerformanceMeasure where
-  pFromJSVal = PerformanceMeasure
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal PerformanceMeasure where
-  toJSVal = return . unPerformanceMeasure
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal PerformanceMeasure where
-  fromJSVal = return . fmap PerformanceMeasure . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsPerformanceEntry PerformanceMeasure
-instance IsGObject PerformanceMeasure where
-  toGObject = GObject . unPerformanceMeasure
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = PerformanceMeasure . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToPerformanceMeasure :: IsGObject obj => obj -> IO PerformanceMeasure
-castToPerformanceMeasure = castTo gTypePerformanceMeasure "PerformanceMeasure"
-
-foreign import javascript unsafe "window[\"PerformanceMeasure\"]" gTypePerformanceMeasure :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.PerformanceNavigation".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/PerformanceNavigation Mozilla PerformanceNavigation documentation>
-newtype PerformanceNavigation = PerformanceNavigation { unPerformanceNavigation :: JSVal }
-
-instance Eq (PerformanceNavigation) where
-  (PerformanceNavigation a) == (PerformanceNavigation b) = js_eq a b
-
-instance PToJSVal PerformanceNavigation where
-  pToJSVal = unPerformanceNavigation
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal PerformanceNavigation where
-  pFromJSVal = PerformanceNavigation
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal PerformanceNavigation where
-  toJSVal = return . unPerformanceNavigation
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal PerformanceNavigation where
-  fromJSVal = return . fmap PerformanceNavigation . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject PerformanceNavigation where
-  toGObject = GObject . unPerformanceNavigation
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = PerformanceNavigation . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToPerformanceNavigation :: IsGObject obj => obj -> IO PerformanceNavigation
-castToPerformanceNavigation = castTo gTypePerformanceNavigation "PerformanceNavigation"
-
-foreign import javascript unsafe "window[\"PerformanceNavigation\"]" gTypePerformanceNavigation :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.PerformanceResourceTiming".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.PerformanceEntry"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/PerformanceResourceTiming Mozilla PerformanceResourceTiming documentation>
-newtype PerformanceResourceTiming = PerformanceResourceTiming { unPerformanceResourceTiming :: JSVal }
-
-instance Eq (PerformanceResourceTiming) where
-  (PerformanceResourceTiming a) == (PerformanceResourceTiming b) = js_eq a b
-
-instance PToJSVal PerformanceResourceTiming where
-  pToJSVal = unPerformanceResourceTiming
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal PerformanceResourceTiming where
-  pFromJSVal = PerformanceResourceTiming
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal PerformanceResourceTiming where
-  toJSVal = return . unPerformanceResourceTiming
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal PerformanceResourceTiming where
-  fromJSVal = return . fmap PerformanceResourceTiming . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsPerformanceEntry PerformanceResourceTiming
-instance IsGObject PerformanceResourceTiming where
-  toGObject = GObject . unPerformanceResourceTiming
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = PerformanceResourceTiming . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToPerformanceResourceTiming :: IsGObject obj => obj -> IO PerformanceResourceTiming
-castToPerformanceResourceTiming = castTo gTypePerformanceResourceTiming "PerformanceResourceTiming"
-
-foreign import javascript unsafe "window[\"PerformanceResourceTiming\"]" gTypePerformanceResourceTiming :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.PerformanceTiming".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/PerformanceTiming Mozilla PerformanceTiming documentation>
-newtype PerformanceTiming = PerformanceTiming { unPerformanceTiming :: JSVal }
-
-instance Eq (PerformanceTiming) where
-  (PerformanceTiming a) == (PerformanceTiming b) = js_eq a b
-
-instance PToJSVal PerformanceTiming where
-  pToJSVal = unPerformanceTiming
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal PerformanceTiming where
-  pFromJSVal = PerformanceTiming
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal PerformanceTiming where
-  toJSVal = return . unPerformanceTiming
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal PerformanceTiming where
-  fromJSVal = return . fmap PerformanceTiming . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject PerformanceTiming where
-  toGObject = GObject . unPerformanceTiming
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = PerformanceTiming . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToPerformanceTiming :: IsGObject obj => obj -> IO PerformanceTiming
-castToPerformanceTiming = castTo gTypePerformanceTiming "PerformanceTiming"
-
-foreign import javascript unsafe "window[\"PerformanceTiming\"]" gTypePerformanceTiming :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.PeriodicWave".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/PeriodicWave Mozilla PeriodicWave documentation>
-newtype PeriodicWave = PeriodicWave { unPeriodicWave :: JSVal }
-
-instance Eq (PeriodicWave) where
-  (PeriodicWave a) == (PeriodicWave b) = js_eq a b
-
-instance PToJSVal PeriodicWave where
-  pToJSVal = unPeriodicWave
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal PeriodicWave where
-  pFromJSVal = PeriodicWave
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal PeriodicWave where
-  toJSVal = return . unPeriodicWave
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal PeriodicWave where
-  fromJSVal = return . fmap PeriodicWave . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject PeriodicWave where
-  toGObject = GObject . unPeriodicWave
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = PeriodicWave . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToPeriodicWave :: IsGObject obj => obj -> IO PeriodicWave
-castToPeriodicWave = castTo gTypePeriodicWave "PeriodicWave"
-
-foreign import javascript unsafe "window[\"PeriodicWave\"]" gTypePeriodicWave :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.Plugin".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/Plugin Mozilla Plugin documentation>
-newtype Plugin = Plugin { unPlugin :: JSVal }
-
-instance Eq (Plugin) where
-  (Plugin a) == (Plugin b) = js_eq a b
-
-instance PToJSVal Plugin where
-  pToJSVal = unPlugin
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal Plugin where
-  pFromJSVal = Plugin
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal Plugin where
-  toJSVal = return . unPlugin
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal Plugin where
-  fromJSVal = return . fmap Plugin . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject Plugin where
-  toGObject = GObject . unPlugin
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = Plugin . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToPlugin :: IsGObject obj => obj -> IO Plugin
-castToPlugin = castTo gTypePlugin "Plugin"
-
-foreign import javascript unsafe "window[\"Plugin\"]" gTypePlugin :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.PluginArray".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/PluginArray Mozilla PluginArray documentation>
-newtype PluginArray = PluginArray { unPluginArray :: JSVal }
-
-instance Eq (PluginArray) where
-  (PluginArray a) == (PluginArray b) = js_eq a b
-
-instance PToJSVal PluginArray where
-  pToJSVal = unPluginArray
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal PluginArray where
-  pFromJSVal = PluginArray
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal PluginArray where
-  toJSVal = return . unPluginArray
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal PluginArray where
-  fromJSVal = return . fmap PluginArray . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject PluginArray where
-  toGObject = GObject . unPluginArray
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = PluginArray . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToPluginArray :: IsGObject obj => obj -> IO PluginArray
-castToPluginArray = castTo gTypePluginArray "PluginArray"
-
-foreign import javascript unsafe "window[\"PluginArray\"]" gTypePluginArray :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.PopStateEvent".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.Event"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/PopStateEvent Mozilla PopStateEvent documentation>
-newtype PopStateEvent = PopStateEvent { unPopStateEvent :: JSVal }
-
-instance Eq (PopStateEvent) where
-  (PopStateEvent a) == (PopStateEvent b) = js_eq a b
-
-instance PToJSVal PopStateEvent where
-  pToJSVal = unPopStateEvent
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal PopStateEvent where
-  pFromJSVal = PopStateEvent
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal PopStateEvent where
-  toJSVal = return . unPopStateEvent
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal PopStateEvent where
-  fromJSVal = return . fmap PopStateEvent . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsEvent PopStateEvent
-instance IsGObject PopStateEvent where
-  toGObject = GObject . unPopStateEvent
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = PopStateEvent . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToPopStateEvent :: IsGObject obj => obj -> IO PopStateEvent
-castToPopStateEvent = castTo gTypePopStateEvent "PopStateEvent"
-
-foreign import javascript unsafe "window[\"PopStateEvent\"]" gTypePopStateEvent :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.PositionError".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/PositionError Mozilla PositionError documentation>
-newtype PositionError = PositionError { unPositionError :: JSVal }
-
-instance Eq (PositionError) where
-  (PositionError a) == (PositionError b) = js_eq a b
-
-instance PToJSVal PositionError where
-  pToJSVal = unPositionError
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal PositionError where
-  pFromJSVal = PositionError
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal PositionError where
-  toJSVal = return . unPositionError
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal PositionError where
-  fromJSVal = return . fmap PositionError . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject PositionError where
-  toGObject = GObject . unPositionError
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = PositionError . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToPositionError :: IsGObject obj => obj -> IO PositionError
-castToPositionError = castTo gTypePositionError "PositionError"
-
-foreign import javascript unsafe "window[\"PositionError\"]" gTypePositionError :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.ProcessingInstruction".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.CharacterData"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/ProcessingInstruction Mozilla ProcessingInstruction documentation>
-newtype ProcessingInstruction = ProcessingInstruction { unProcessingInstruction :: JSVal }
-
-instance Eq (ProcessingInstruction) where
-  (ProcessingInstruction a) == (ProcessingInstruction b) = js_eq a b
-
-instance PToJSVal ProcessingInstruction where
-  pToJSVal = unProcessingInstruction
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal ProcessingInstruction where
-  pFromJSVal = ProcessingInstruction
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal ProcessingInstruction where
-  toJSVal = return . unProcessingInstruction
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal ProcessingInstruction where
-  fromJSVal = return . fmap ProcessingInstruction . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsCharacterData ProcessingInstruction
-instance IsNode ProcessingInstruction
-instance IsEventTarget ProcessingInstruction
-instance IsGObject ProcessingInstruction where
-  toGObject = GObject . unProcessingInstruction
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = ProcessingInstruction . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToProcessingInstruction :: IsGObject obj => obj -> IO ProcessingInstruction
-castToProcessingInstruction = castTo gTypeProcessingInstruction "ProcessingInstruction"
-
-foreign import javascript unsafe "window[\"ProcessingInstruction\"]" gTypeProcessingInstruction :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.ProgressEvent".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.Event"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/ProgressEvent Mozilla ProgressEvent documentation>
-newtype ProgressEvent = ProgressEvent { unProgressEvent :: JSVal }
-
-instance Eq (ProgressEvent) where
-  (ProgressEvent a) == (ProgressEvent b) = js_eq a b
-
-instance PToJSVal ProgressEvent where
-  pToJSVal = unProgressEvent
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal ProgressEvent where
-  pFromJSVal = ProgressEvent
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal ProgressEvent where
-  toJSVal = return . unProgressEvent
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal ProgressEvent where
-  fromJSVal = return . fmap ProgressEvent . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-class IsEvent o => IsProgressEvent o
-toProgressEvent :: IsProgressEvent o => o -> ProgressEvent
-toProgressEvent = unsafeCastGObject . toGObject
-
-instance IsProgressEvent ProgressEvent
-instance IsEvent ProgressEvent
-instance IsGObject ProgressEvent where
-  toGObject = GObject . unProgressEvent
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = ProgressEvent . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToProgressEvent :: IsGObject obj => obj -> IO ProgressEvent
-castToProgressEvent = castTo gTypeProgressEvent "ProgressEvent"
-
-foreign import javascript unsafe "window[\"ProgressEvent\"]" gTypeProgressEvent :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.QuickTimePluginReplacement".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/QuickTimePluginReplacement Mozilla QuickTimePluginReplacement documentation>
-newtype QuickTimePluginReplacement = QuickTimePluginReplacement { unQuickTimePluginReplacement :: JSVal }
-
-instance Eq (QuickTimePluginReplacement) where
-  (QuickTimePluginReplacement a) == (QuickTimePluginReplacement b) = js_eq a b
-
-instance PToJSVal QuickTimePluginReplacement where
-  pToJSVal = unQuickTimePluginReplacement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal QuickTimePluginReplacement where
-  pFromJSVal = QuickTimePluginReplacement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal QuickTimePluginReplacement where
-  toJSVal = return . unQuickTimePluginReplacement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal QuickTimePluginReplacement where
-  fromJSVal = return . fmap QuickTimePluginReplacement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject QuickTimePluginReplacement where
-  toGObject = GObject . unQuickTimePluginReplacement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = QuickTimePluginReplacement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToQuickTimePluginReplacement :: IsGObject obj => obj -> IO QuickTimePluginReplacement
-castToQuickTimePluginReplacement = castTo gTypeQuickTimePluginReplacement "QuickTimePluginReplacement"
-
-foreign import javascript unsafe "window[\"QuickTimePluginReplacement\"]" gTypeQuickTimePluginReplacement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.RGBColor".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/RGBColor Mozilla RGBColor documentation>
-newtype RGBColor = RGBColor { unRGBColor :: JSVal }
-
-instance Eq (RGBColor) where
-  (RGBColor a) == (RGBColor b) = js_eq a b
-
-instance PToJSVal RGBColor where
-  pToJSVal = unRGBColor
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal RGBColor where
-  pFromJSVal = RGBColor
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal RGBColor where
-  toJSVal = return . unRGBColor
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal RGBColor where
-  fromJSVal = return . fmap RGBColor . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject RGBColor where
-  toGObject = GObject . unRGBColor
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = RGBColor . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToRGBColor :: IsGObject obj => obj -> IO RGBColor
-castToRGBColor = castTo gTypeRGBColor "RGBColor"
-
-foreign import javascript unsafe "window[\"RGBColor\"]" gTypeRGBColor :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.RTCConfiguration".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/RTCConfiguration Mozilla RTCConfiguration documentation>
-newtype RTCConfiguration = RTCConfiguration { unRTCConfiguration :: JSVal }
-
-instance Eq (RTCConfiguration) where
-  (RTCConfiguration a) == (RTCConfiguration b) = js_eq a b
-
-instance PToJSVal RTCConfiguration where
-  pToJSVal = unRTCConfiguration
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal RTCConfiguration where
-  pFromJSVal = RTCConfiguration
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal RTCConfiguration where
-  toJSVal = return . unRTCConfiguration
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal RTCConfiguration where
-  fromJSVal = return . fmap RTCConfiguration . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject RTCConfiguration where
-  toGObject = GObject . unRTCConfiguration
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = RTCConfiguration . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToRTCConfiguration :: IsGObject obj => obj -> IO RTCConfiguration
-castToRTCConfiguration = castTo gTypeRTCConfiguration "RTCConfiguration"
-
-foreign import javascript unsafe "window[\"RTCConfiguration\"]" gTypeRTCConfiguration :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.RTCDTMFSender".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/RTCDTMFSender Mozilla RTCDTMFSender documentation>
-newtype RTCDTMFSender = RTCDTMFSender { unRTCDTMFSender :: JSVal }
-
-instance Eq (RTCDTMFSender) where
-  (RTCDTMFSender a) == (RTCDTMFSender b) = js_eq a b
-
-instance PToJSVal RTCDTMFSender where
-  pToJSVal = unRTCDTMFSender
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal RTCDTMFSender where
-  pFromJSVal = RTCDTMFSender
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal RTCDTMFSender where
-  toJSVal = return . unRTCDTMFSender
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal RTCDTMFSender where
-  fromJSVal = return . fmap RTCDTMFSender . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsEventTarget RTCDTMFSender
-instance IsGObject RTCDTMFSender where
-  toGObject = GObject . unRTCDTMFSender
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = RTCDTMFSender . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToRTCDTMFSender :: IsGObject obj => obj -> IO RTCDTMFSender
-castToRTCDTMFSender = castTo gTypeRTCDTMFSender "RTCDTMFSender"
-
-foreign import javascript unsafe "window[\"RTCDTMFSender\"]" gTypeRTCDTMFSender :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.RTCDTMFToneChangeEvent".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.Event"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/RTCDTMFToneChangeEvent Mozilla RTCDTMFToneChangeEvent documentation>
-newtype RTCDTMFToneChangeEvent = RTCDTMFToneChangeEvent { unRTCDTMFToneChangeEvent :: JSVal }
-
-instance Eq (RTCDTMFToneChangeEvent) where
-  (RTCDTMFToneChangeEvent a) == (RTCDTMFToneChangeEvent b) = js_eq a b
-
-instance PToJSVal RTCDTMFToneChangeEvent where
-  pToJSVal = unRTCDTMFToneChangeEvent
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal RTCDTMFToneChangeEvent where
-  pFromJSVal = RTCDTMFToneChangeEvent
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal RTCDTMFToneChangeEvent where
-  toJSVal = return . unRTCDTMFToneChangeEvent
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal RTCDTMFToneChangeEvent where
-  fromJSVal = return . fmap RTCDTMFToneChangeEvent . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsEvent RTCDTMFToneChangeEvent
-instance IsGObject RTCDTMFToneChangeEvent where
-  toGObject = GObject . unRTCDTMFToneChangeEvent
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = RTCDTMFToneChangeEvent . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToRTCDTMFToneChangeEvent :: IsGObject obj => obj -> IO RTCDTMFToneChangeEvent
-castToRTCDTMFToneChangeEvent = castTo gTypeRTCDTMFToneChangeEvent "RTCDTMFToneChangeEvent"
-
-foreign import javascript unsafe "window[\"RTCDTMFToneChangeEvent\"]" gTypeRTCDTMFToneChangeEvent :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.RTCDataChannel".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/RTCDataChannel Mozilla RTCDataChannel documentation>
-newtype RTCDataChannel = RTCDataChannel { unRTCDataChannel :: JSVal }
-
-instance Eq (RTCDataChannel) where
-  (RTCDataChannel a) == (RTCDataChannel b) = js_eq a b
-
-instance PToJSVal RTCDataChannel where
-  pToJSVal = unRTCDataChannel
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal RTCDataChannel where
-  pFromJSVal = RTCDataChannel
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal RTCDataChannel where
-  toJSVal = return . unRTCDataChannel
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal RTCDataChannel where
-  fromJSVal = return . fmap RTCDataChannel . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsEventTarget RTCDataChannel
-instance IsGObject RTCDataChannel where
-  toGObject = GObject . unRTCDataChannel
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = RTCDataChannel . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToRTCDataChannel :: IsGObject obj => obj -> IO RTCDataChannel
-castToRTCDataChannel = castTo gTypeRTCDataChannel "RTCDataChannel"
-
-foreign import javascript unsafe "window[\"RTCDataChannel\"]" gTypeRTCDataChannel :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.RTCDataChannelEvent".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.Event"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/RTCDataChannelEvent Mozilla RTCDataChannelEvent documentation>
-newtype RTCDataChannelEvent = RTCDataChannelEvent { unRTCDataChannelEvent :: JSVal }
-
-instance Eq (RTCDataChannelEvent) where
-  (RTCDataChannelEvent a) == (RTCDataChannelEvent b) = js_eq a b
-
-instance PToJSVal RTCDataChannelEvent where
-  pToJSVal = unRTCDataChannelEvent
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal RTCDataChannelEvent where
-  pFromJSVal = RTCDataChannelEvent
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal RTCDataChannelEvent where
-  toJSVal = return . unRTCDataChannelEvent
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal RTCDataChannelEvent where
-  fromJSVal = return . fmap RTCDataChannelEvent . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsEvent RTCDataChannelEvent
-instance IsGObject RTCDataChannelEvent where
-  toGObject = GObject . unRTCDataChannelEvent
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = RTCDataChannelEvent . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToRTCDataChannelEvent :: IsGObject obj => obj -> IO RTCDataChannelEvent
-castToRTCDataChannelEvent = castTo gTypeRTCDataChannelEvent "RTCDataChannelEvent"
-
-foreign import javascript unsafe "window[\"RTCDataChannelEvent\"]" gTypeRTCDataChannelEvent :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.RTCIceCandidate".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/RTCIceCandidate Mozilla RTCIceCandidate documentation>
-newtype RTCIceCandidate = RTCIceCandidate { unRTCIceCandidate :: JSVal }
-
-instance Eq (RTCIceCandidate) where
-  (RTCIceCandidate a) == (RTCIceCandidate b) = js_eq a b
-
-instance PToJSVal RTCIceCandidate where
-  pToJSVal = unRTCIceCandidate
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal RTCIceCandidate where
-  pFromJSVal = RTCIceCandidate
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal RTCIceCandidate where
-  toJSVal = return . unRTCIceCandidate
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal RTCIceCandidate where
-  fromJSVal = return . fmap RTCIceCandidate . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject RTCIceCandidate where
-  toGObject = GObject . unRTCIceCandidate
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = RTCIceCandidate . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToRTCIceCandidate :: IsGObject obj => obj -> IO RTCIceCandidate
-castToRTCIceCandidate = castTo gTypeRTCIceCandidate "RTCIceCandidate"
-
-foreign import javascript unsafe "window[\"RTCIceCandidate\"]" gTypeRTCIceCandidate :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.RTCIceCandidateEvent".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.Event"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/RTCIceCandidateEvent Mozilla RTCIceCandidateEvent documentation>
-newtype RTCIceCandidateEvent = RTCIceCandidateEvent { unRTCIceCandidateEvent :: JSVal }
-
-instance Eq (RTCIceCandidateEvent) where
-  (RTCIceCandidateEvent a) == (RTCIceCandidateEvent b) = js_eq a b
-
-instance PToJSVal RTCIceCandidateEvent where
-  pToJSVal = unRTCIceCandidateEvent
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal RTCIceCandidateEvent where
-  pFromJSVal = RTCIceCandidateEvent
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal RTCIceCandidateEvent where
-  toJSVal = return . unRTCIceCandidateEvent
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal RTCIceCandidateEvent where
-  fromJSVal = return . fmap RTCIceCandidateEvent . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsEvent RTCIceCandidateEvent
-instance IsGObject RTCIceCandidateEvent where
-  toGObject = GObject . unRTCIceCandidateEvent
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = RTCIceCandidateEvent . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToRTCIceCandidateEvent :: IsGObject obj => obj -> IO RTCIceCandidateEvent
-castToRTCIceCandidateEvent = castTo gTypeRTCIceCandidateEvent "RTCIceCandidateEvent"
-
-foreign import javascript unsafe "window[\"RTCIceCandidateEvent\"]" gTypeRTCIceCandidateEvent :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.RTCIceServer".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/RTCIceServer Mozilla RTCIceServer documentation>
-newtype RTCIceServer = RTCIceServer { unRTCIceServer :: JSVal }
-
-instance Eq (RTCIceServer) where
-  (RTCIceServer a) == (RTCIceServer b) = js_eq a b
-
-instance PToJSVal RTCIceServer where
-  pToJSVal = unRTCIceServer
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal RTCIceServer where
-  pFromJSVal = RTCIceServer
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal RTCIceServer where
-  toJSVal = return . unRTCIceServer
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal RTCIceServer where
-  fromJSVal = return . fmap RTCIceServer . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject RTCIceServer where
-  toGObject = GObject . unRTCIceServer
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = RTCIceServer . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToRTCIceServer :: IsGObject obj => obj -> IO RTCIceServer
-castToRTCIceServer = castTo gTypeRTCIceServer "RTCIceServer"
-
-foreign import javascript unsafe "window[\"RTCIceServer\"]" gTypeRTCIceServer :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.RTCPeerConnection".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/webkitRTCPeerConnection Mozilla webkitRTCPeerConnection documentation>
-newtype RTCPeerConnection = RTCPeerConnection { unRTCPeerConnection :: JSVal }
-
-instance Eq (RTCPeerConnection) where
-  (RTCPeerConnection a) == (RTCPeerConnection b) = js_eq a b
-
-instance PToJSVal RTCPeerConnection where
-  pToJSVal = unRTCPeerConnection
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal RTCPeerConnection where
-  pFromJSVal = RTCPeerConnection
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal RTCPeerConnection where
-  toJSVal = return . unRTCPeerConnection
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal RTCPeerConnection where
-  fromJSVal = return . fmap RTCPeerConnection . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsEventTarget RTCPeerConnection
-instance IsGObject RTCPeerConnection where
-  toGObject = GObject . unRTCPeerConnection
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = RTCPeerConnection . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToRTCPeerConnection :: IsGObject obj => obj -> IO RTCPeerConnection
-castToRTCPeerConnection = castTo gTypeRTCPeerConnection "RTCPeerConnection"
-
-foreign import javascript unsafe "window[\"webkitRTCPeerConnection\"]" gTypeRTCPeerConnection :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.RTCSessionDescription".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/RTCSessionDescription Mozilla RTCSessionDescription documentation>
-newtype RTCSessionDescription = RTCSessionDescription { unRTCSessionDescription :: JSVal }
-
-instance Eq (RTCSessionDescription) where
-  (RTCSessionDescription a) == (RTCSessionDescription b) = js_eq a b
-
-instance PToJSVal RTCSessionDescription where
-  pToJSVal = unRTCSessionDescription
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal RTCSessionDescription where
-  pFromJSVal = RTCSessionDescription
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal RTCSessionDescription where
-  toJSVal = return . unRTCSessionDescription
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal RTCSessionDescription where
-  fromJSVal = return . fmap RTCSessionDescription . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject RTCSessionDescription where
-  toGObject = GObject . unRTCSessionDescription
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = RTCSessionDescription . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToRTCSessionDescription :: IsGObject obj => obj -> IO RTCSessionDescription
-castToRTCSessionDescription = castTo gTypeRTCSessionDescription "RTCSessionDescription"
-
-foreign import javascript unsafe "window[\"RTCSessionDescription\"]" gTypeRTCSessionDescription :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.RTCStatsReport".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/RTCStatsReport Mozilla RTCStatsReport documentation>
-newtype RTCStatsReport = RTCStatsReport { unRTCStatsReport :: JSVal }
-
-instance Eq (RTCStatsReport) where
-  (RTCStatsReport a) == (RTCStatsReport b) = js_eq a b
-
-instance PToJSVal RTCStatsReport where
-  pToJSVal = unRTCStatsReport
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal RTCStatsReport where
-  pFromJSVal = RTCStatsReport
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal RTCStatsReport where
-  toJSVal = return . unRTCStatsReport
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal RTCStatsReport where
-  fromJSVal = return . fmap RTCStatsReport . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject RTCStatsReport where
-  toGObject = GObject . unRTCStatsReport
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = RTCStatsReport . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToRTCStatsReport :: IsGObject obj => obj -> IO RTCStatsReport
-castToRTCStatsReport = castTo gTypeRTCStatsReport "RTCStatsReport"
-
-foreign import javascript unsafe "window[\"RTCStatsReport\"]" gTypeRTCStatsReport :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.RTCStatsResponse".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/RTCStatsResponse Mozilla RTCStatsResponse documentation>
-newtype RTCStatsResponse = RTCStatsResponse { unRTCStatsResponse :: JSVal }
-
-instance Eq (RTCStatsResponse) where
-  (RTCStatsResponse a) == (RTCStatsResponse b) = js_eq a b
-
-instance PToJSVal RTCStatsResponse where
-  pToJSVal = unRTCStatsResponse
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal RTCStatsResponse where
-  pFromJSVal = RTCStatsResponse
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal RTCStatsResponse where
-  toJSVal = return . unRTCStatsResponse
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal RTCStatsResponse where
-  fromJSVal = return . fmap RTCStatsResponse . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject RTCStatsResponse where
-  toGObject = GObject . unRTCStatsResponse
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = RTCStatsResponse . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToRTCStatsResponse :: IsGObject obj => obj -> IO RTCStatsResponse
-castToRTCStatsResponse = castTo gTypeRTCStatsResponse "RTCStatsResponse"
-
-foreign import javascript unsafe "window[\"RTCStatsResponse\"]" gTypeRTCStatsResponse :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.RadioNodeList".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.NodeList"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/RadioNodeList Mozilla RadioNodeList documentation>
-newtype RadioNodeList = RadioNodeList { unRadioNodeList :: JSVal }
-
-instance Eq (RadioNodeList) where
-  (RadioNodeList a) == (RadioNodeList b) = js_eq a b
-
-instance PToJSVal RadioNodeList where
-  pToJSVal = unRadioNodeList
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal RadioNodeList where
-  pFromJSVal = RadioNodeList
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal RadioNodeList where
-  toJSVal = return . unRadioNodeList
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal RadioNodeList where
-  fromJSVal = return . fmap RadioNodeList . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsNodeList RadioNodeList
-instance IsGObject RadioNodeList where
-  toGObject = GObject . unRadioNodeList
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = RadioNodeList . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToRadioNodeList :: IsGObject obj => obj -> IO RadioNodeList
-castToRadioNodeList = castTo gTypeRadioNodeList "RadioNodeList"
-
-foreign import javascript unsafe "window[\"RadioNodeList\"]" gTypeRadioNodeList :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.Range".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/Range Mozilla Range documentation>
-newtype Range = Range { unRange :: JSVal }
-
-instance Eq (Range) where
-  (Range a) == (Range b) = js_eq a b
-
-instance PToJSVal Range where
-  pToJSVal = unRange
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal Range where
-  pFromJSVal = Range
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal Range where
-  toJSVal = return . unRange
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal Range where
-  fromJSVal = return . fmap Range . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject Range where
-  toGObject = GObject . unRange
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = Range . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToRange :: IsGObject obj => obj -> IO Range
-castToRange = castTo gTypeRange "Range"
-
-foreign import javascript unsafe "window[\"Range\"]" gTypeRange :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.ReadableStream".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream Mozilla ReadableStream documentation>
-newtype ReadableStream = ReadableStream { unReadableStream :: JSVal }
-
-instance Eq (ReadableStream) where
-  (ReadableStream a) == (ReadableStream b) = js_eq a b
-
-instance PToJSVal ReadableStream where
-  pToJSVal = unReadableStream
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal ReadableStream where
-  pFromJSVal = ReadableStream
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal ReadableStream where
-  toJSVal = return . unReadableStream
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal ReadableStream where
-  fromJSVal = return . fmap ReadableStream . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject ReadableStream where
-  toGObject = GObject . unReadableStream
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = ReadableStream . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToReadableStream :: IsGObject obj => obj -> IO ReadableStream
-castToReadableStream = castTo gTypeReadableStream "ReadableStream"
-
-foreign import javascript unsafe "window[\"ReadableStream\"]" gTypeReadableStream :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.Rect".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/Rect Mozilla Rect documentation>
-newtype Rect = Rect { unRect :: JSVal }
-
-instance Eq (Rect) where
-  (Rect a) == (Rect b) = js_eq a b
-
-instance PToJSVal Rect where
-  pToJSVal = unRect
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal Rect where
-  pFromJSVal = Rect
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal Rect where
-  toJSVal = return . unRect
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal Rect where
-  fromJSVal = return . fmap Rect . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject Rect where
-  toGObject = GObject . unRect
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = Rect . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToRect :: IsGObject obj => obj -> IO Rect
-castToRect = castTo gTypeRect "Rect"
-
-foreign import javascript unsafe "window[\"Rect\"]" gTypeRect :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SQLError".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SQLError Mozilla SQLError documentation>
-newtype SQLError = SQLError { unSQLError :: JSVal }
-
-instance Eq (SQLError) where
-  (SQLError a) == (SQLError b) = js_eq a b
-
-instance PToJSVal SQLError where
-  pToJSVal = unSQLError
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SQLError where
-  pFromJSVal = SQLError
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SQLError where
-  toJSVal = return . unSQLError
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SQLError where
-  fromJSVal = return . fmap SQLError . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject SQLError where
-  toGObject = GObject . unSQLError
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SQLError . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSQLError :: IsGObject obj => obj -> IO SQLError
-castToSQLError = castTo gTypeSQLError "SQLError"
-
-foreign import javascript unsafe "window[\"SQLError\"]" gTypeSQLError :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SQLResultSet".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SQLResultSet Mozilla SQLResultSet documentation>
-newtype SQLResultSet = SQLResultSet { unSQLResultSet :: JSVal }
-
-instance Eq (SQLResultSet) where
-  (SQLResultSet a) == (SQLResultSet b) = js_eq a b
-
-instance PToJSVal SQLResultSet where
-  pToJSVal = unSQLResultSet
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SQLResultSet where
-  pFromJSVal = SQLResultSet
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SQLResultSet where
-  toJSVal = return . unSQLResultSet
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SQLResultSet where
-  fromJSVal = return . fmap SQLResultSet . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject SQLResultSet where
-  toGObject = GObject . unSQLResultSet
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SQLResultSet . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSQLResultSet :: IsGObject obj => obj -> IO SQLResultSet
-castToSQLResultSet = castTo gTypeSQLResultSet "SQLResultSet"
-
-foreign import javascript unsafe "window[\"SQLResultSet\"]" gTypeSQLResultSet :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SQLResultSetRowList".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SQLResultSetRowList Mozilla SQLResultSetRowList documentation>
-newtype SQLResultSetRowList = SQLResultSetRowList { unSQLResultSetRowList :: JSVal }
-
-instance Eq (SQLResultSetRowList) where
-  (SQLResultSetRowList a) == (SQLResultSetRowList b) = js_eq a b
-
-instance PToJSVal SQLResultSetRowList where
-  pToJSVal = unSQLResultSetRowList
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SQLResultSetRowList where
-  pFromJSVal = SQLResultSetRowList
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SQLResultSetRowList where
-  toJSVal = return . unSQLResultSetRowList
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SQLResultSetRowList where
-  fromJSVal = return . fmap SQLResultSetRowList . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject SQLResultSetRowList where
-  toGObject = GObject . unSQLResultSetRowList
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SQLResultSetRowList . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSQLResultSetRowList :: IsGObject obj => obj -> IO SQLResultSetRowList
-castToSQLResultSetRowList = castTo gTypeSQLResultSetRowList "SQLResultSetRowList"
-
-foreign import javascript unsafe "window[\"SQLResultSetRowList\"]" gTypeSQLResultSetRowList :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SQLTransaction".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SQLTransaction Mozilla SQLTransaction documentation>
-newtype SQLTransaction = SQLTransaction { unSQLTransaction :: JSVal }
-
-instance Eq (SQLTransaction) where
-  (SQLTransaction a) == (SQLTransaction b) = js_eq a b
-
-instance PToJSVal SQLTransaction where
-  pToJSVal = unSQLTransaction
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SQLTransaction where
-  pFromJSVal = SQLTransaction
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SQLTransaction where
-  toJSVal = return . unSQLTransaction
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SQLTransaction where
-  fromJSVal = return . fmap SQLTransaction . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject SQLTransaction where
-  toGObject = GObject . unSQLTransaction
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SQLTransaction . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSQLTransaction :: IsGObject obj => obj -> IO SQLTransaction
-castToSQLTransaction = castTo gTypeSQLTransaction "SQLTransaction"
-
-foreign import javascript unsafe "window[\"SQLTransaction\"]" gTypeSQLTransaction :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SVGAElement".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.SVGGraphicsElement"
---     * "GHCJS.DOM.SVGElement"
---     * "GHCJS.DOM.Element"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SVGAElement Mozilla SVGAElement documentation>
-newtype SVGAElement = SVGAElement { unSVGAElement :: JSVal }
-
-instance Eq (SVGAElement) where
-  (SVGAElement a) == (SVGAElement b) = js_eq a b
-
-instance PToJSVal SVGAElement where
-  pToJSVal = unSVGAElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SVGAElement where
-  pFromJSVal = SVGAElement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SVGAElement where
-  toJSVal = return . unSVGAElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SVGAElement where
-  fromJSVal = return . fmap SVGAElement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsSVGGraphicsElement SVGAElement
-instance IsSVGElement SVGAElement
-instance IsElement SVGAElement
-instance IsNode SVGAElement
-instance IsEventTarget SVGAElement
-instance IsGObject SVGAElement where
-  toGObject = GObject . unSVGAElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SVGAElement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSVGAElement :: IsGObject obj => obj -> IO SVGAElement
-castToSVGAElement = castTo gTypeSVGAElement "SVGAElement"
-
-foreign import javascript unsafe "window[\"SVGAElement\"]" gTypeSVGAElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SVGAltGlyphDefElement".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.SVGElement"
---     * "GHCJS.DOM.Element"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SVGAltGlyphDefElement Mozilla SVGAltGlyphDefElement documentation>
-newtype SVGAltGlyphDefElement = SVGAltGlyphDefElement { unSVGAltGlyphDefElement :: JSVal }
-
-instance Eq (SVGAltGlyphDefElement) where
-  (SVGAltGlyphDefElement a) == (SVGAltGlyphDefElement b) = js_eq a b
-
-instance PToJSVal SVGAltGlyphDefElement where
-  pToJSVal = unSVGAltGlyphDefElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SVGAltGlyphDefElement where
-  pFromJSVal = SVGAltGlyphDefElement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SVGAltGlyphDefElement where
-  toJSVal = return . unSVGAltGlyphDefElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SVGAltGlyphDefElement where
-  fromJSVal = return . fmap SVGAltGlyphDefElement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsSVGElement SVGAltGlyphDefElement
-instance IsElement SVGAltGlyphDefElement
-instance IsNode SVGAltGlyphDefElement
-instance IsEventTarget SVGAltGlyphDefElement
-instance IsGObject SVGAltGlyphDefElement where
-  toGObject = GObject . unSVGAltGlyphDefElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SVGAltGlyphDefElement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSVGAltGlyphDefElement :: IsGObject obj => obj -> IO SVGAltGlyphDefElement
-castToSVGAltGlyphDefElement = castTo gTypeSVGAltGlyphDefElement "SVGAltGlyphDefElement"
-
-foreign import javascript unsafe "window[\"SVGAltGlyphDefElement\"]" gTypeSVGAltGlyphDefElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SVGAltGlyphElement".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.SVGTextPositioningElement"
---     * "GHCJS.DOM.SVGTextContentElement"
---     * "GHCJS.DOM.SVGGraphicsElement"
---     * "GHCJS.DOM.SVGElement"
---     * "GHCJS.DOM.Element"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SVGAltGlyphElement Mozilla SVGAltGlyphElement documentation>
-newtype SVGAltGlyphElement = SVGAltGlyphElement { unSVGAltGlyphElement :: JSVal }
-
-instance Eq (SVGAltGlyphElement) where
-  (SVGAltGlyphElement a) == (SVGAltGlyphElement b) = js_eq a b
-
-instance PToJSVal SVGAltGlyphElement where
-  pToJSVal = unSVGAltGlyphElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SVGAltGlyphElement where
-  pFromJSVal = SVGAltGlyphElement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SVGAltGlyphElement where
-  toJSVal = return . unSVGAltGlyphElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SVGAltGlyphElement where
-  fromJSVal = return . fmap SVGAltGlyphElement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsSVGTextPositioningElement SVGAltGlyphElement
-instance IsSVGTextContentElement SVGAltGlyphElement
-instance IsSVGGraphicsElement SVGAltGlyphElement
-instance IsSVGElement SVGAltGlyphElement
-instance IsElement SVGAltGlyphElement
-instance IsNode SVGAltGlyphElement
-instance IsEventTarget SVGAltGlyphElement
-instance IsGObject SVGAltGlyphElement where
-  toGObject = GObject . unSVGAltGlyphElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SVGAltGlyphElement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSVGAltGlyphElement :: IsGObject obj => obj -> IO SVGAltGlyphElement
-castToSVGAltGlyphElement = castTo gTypeSVGAltGlyphElement "SVGAltGlyphElement"
-
-foreign import javascript unsafe "window[\"SVGAltGlyphElement\"]" gTypeSVGAltGlyphElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SVGAltGlyphItemElement".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.SVGElement"
---     * "GHCJS.DOM.Element"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SVGAltGlyphItemElement Mozilla SVGAltGlyphItemElement documentation>
-newtype SVGAltGlyphItemElement = SVGAltGlyphItemElement { unSVGAltGlyphItemElement :: JSVal }
-
-instance Eq (SVGAltGlyphItemElement) where
-  (SVGAltGlyphItemElement a) == (SVGAltGlyphItemElement b) = js_eq a b
-
-instance PToJSVal SVGAltGlyphItemElement where
-  pToJSVal = unSVGAltGlyphItemElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SVGAltGlyphItemElement where
-  pFromJSVal = SVGAltGlyphItemElement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SVGAltGlyphItemElement where
-  toJSVal = return . unSVGAltGlyphItemElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SVGAltGlyphItemElement where
-  fromJSVal = return . fmap SVGAltGlyphItemElement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsSVGElement SVGAltGlyphItemElement
-instance IsElement SVGAltGlyphItemElement
-instance IsNode SVGAltGlyphItemElement
-instance IsEventTarget SVGAltGlyphItemElement
-instance IsGObject SVGAltGlyphItemElement where
-  toGObject = GObject . unSVGAltGlyphItemElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SVGAltGlyphItemElement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSVGAltGlyphItemElement :: IsGObject obj => obj -> IO SVGAltGlyphItemElement
-castToSVGAltGlyphItemElement = castTo gTypeSVGAltGlyphItemElement "SVGAltGlyphItemElement"
-
-foreign import javascript unsafe "window[\"SVGAltGlyphItemElement\"]" gTypeSVGAltGlyphItemElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SVGAngle".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SVGAngle Mozilla SVGAngle documentation>
-newtype SVGAngle = SVGAngle { unSVGAngle :: JSVal }
-
-instance Eq (SVGAngle) where
-  (SVGAngle a) == (SVGAngle b) = js_eq a b
-
-instance PToJSVal SVGAngle where
-  pToJSVal = unSVGAngle
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SVGAngle where
-  pFromJSVal = SVGAngle
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SVGAngle where
-  toJSVal = return . unSVGAngle
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SVGAngle where
-  fromJSVal = return . fmap SVGAngle . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject SVGAngle where
-  toGObject = GObject . unSVGAngle
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SVGAngle . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSVGAngle :: IsGObject obj => obj -> IO SVGAngle
-castToSVGAngle = castTo gTypeSVGAngle "SVGAngle"
-
-foreign import javascript unsafe "window[\"SVGAngle\"]" gTypeSVGAngle :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SVGAnimateColorElement".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.SVGAnimationElement"
---     * "GHCJS.DOM.SVGElement"
---     * "GHCJS.DOM.Element"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SVGAnimateColorElement Mozilla SVGAnimateColorElement documentation>
-newtype SVGAnimateColorElement = SVGAnimateColorElement { unSVGAnimateColorElement :: JSVal }
-
-instance Eq (SVGAnimateColorElement) where
-  (SVGAnimateColorElement a) == (SVGAnimateColorElement b) = js_eq a b
-
-instance PToJSVal SVGAnimateColorElement where
-  pToJSVal = unSVGAnimateColorElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SVGAnimateColorElement where
-  pFromJSVal = SVGAnimateColorElement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SVGAnimateColorElement where
-  toJSVal = return . unSVGAnimateColorElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SVGAnimateColorElement where
-  fromJSVal = return . fmap SVGAnimateColorElement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsSVGAnimationElement SVGAnimateColorElement
-instance IsSVGElement SVGAnimateColorElement
-instance IsElement SVGAnimateColorElement
-instance IsNode SVGAnimateColorElement
-instance IsEventTarget SVGAnimateColorElement
-instance IsGObject SVGAnimateColorElement where
-  toGObject = GObject . unSVGAnimateColorElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SVGAnimateColorElement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSVGAnimateColorElement :: IsGObject obj => obj -> IO SVGAnimateColorElement
-castToSVGAnimateColorElement = castTo gTypeSVGAnimateColorElement "SVGAnimateColorElement"
-
-foreign import javascript unsafe "window[\"SVGAnimateColorElement\"]" gTypeSVGAnimateColorElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SVGAnimateElement".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.SVGAnimationElement"
---     * "GHCJS.DOM.SVGElement"
---     * "GHCJS.DOM.Element"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SVGAnimateElement Mozilla SVGAnimateElement documentation>
-newtype SVGAnimateElement = SVGAnimateElement { unSVGAnimateElement :: JSVal }
-
-instance Eq (SVGAnimateElement) where
-  (SVGAnimateElement a) == (SVGAnimateElement b) = js_eq a b
-
-instance PToJSVal SVGAnimateElement where
-  pToJSVal = unSVGAnimateElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SVGAnimateElement where
-  pFromJSVal = SVGAnimateElement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SVGAnimateElement where
-  toJSVal = return . unSVGAnimateElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SVGAnimateElement where
-  fromJSVal = return . fmap SVGAnimateElement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsSVGAnimationElement SVGAnimateElement
-instance IsSVGElement SVGAnimateElement
-instance IsElement SVGAnimateElement
-instance IsNode SVGAnimateElement
-instance IsEventTarget SVGAnimateElement
-instance IsGObject SVGAnimateElement where
-  toGObject = GObject . unSVGAnimateElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SVGAnimateElement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSVGAnimateElement :: IsGObject obj => obj -> IO SVGAnimateElement
-castToSVGAnimateElement = castTo gTypeSVGAnimateElement "SVGAnimateElement"
-
-foreign import javascript unsafe "window[\"SVGAnimateElement\"]" gTypeSVGAnimateElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SVGAnimateMotionElement".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.SVGAnimationElement"
---     * "GHCJS.DOM.SVGElement"
---     * "GHCJS.DOM.Element"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SVGAnimateMotionElement Mozilla SVGAnimateMotionElement documentation>
-newtype SVGAnimateMotionElement = SVGAnimateMotionElement { unSVGAnimateMotionElement :: JSVal }
-
-instance Eq (SVGAnimateMotionElement) where
-  (SVGAnimateMotionElement a) == (SVGAnimateMotionElement b) = js_eq a b
-
-instance PToJSVal SVGAnimateMotionElement where
-  pToJSVal = unSVGAnimateMotionElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SVGAnimateMotionElement where
-  pFromJSVal = SVGAnimateMotionElement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SVGAnimateMotionElement where
-  toJSVal = return . unSVGAnimateMotionElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SVGAnimateMotionElement where
-  fromJSVal = return . fmap SVGAnimateMotionElement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsSVGAnimationElement SVGAnimateMotionElement
-instance IsSVGElement SVGAnimateMotionElement
-instance IsElement SVGAnimateMotionElement
-instance IsNode SVGAnimateMotionElement
-instance IsEventTarget SVGAnimateMotionElement
-instance IsGObject SVGAnimateMotionElement where
-  toGObject = GObject . unSVGAnimateMotionElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SVGAnimateMotionElement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSVGAnimateMotionElement :: IsGObject obj => obj -> IO SVGAnimateMotionElement
-castToSVGAnimateMotionElement = castTo gTypeSVGAnimateMotionElement "SVGAnimateMotionElement"
-
-foreign import javascript unsafe "window[\"SVGAnimateMotionElement\"]" gTypeSVGAnimateMotionElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SVGAnimateTransformElement".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.SVGAnimationElement"
---     * "GHCJS.DOM.SVGElement"
---     * "GHCJS.DOM.Element"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SVGAnimateTransformElement Mozilla SVGAnimateTransformElement documentation>
-newtype SVGAnimateTransformElement = SVGAnimateTransformElement { unSVGAnimateTransformElement :: JSVal }
-
-instance Eq (SVGAnimateTransformElement) where
-  (SVGAnimateTransformElement a) == (SVGAnimateTransformElement b) = js_eq a b
-
-instance PToJSVal SVGAnimateTransformElement where
-  pToJSVal = unSVGAnimateTransformElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SVGAnimateTransformElement where
-  pFromJSVal = SVGAnimateTransformElement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SVGAnimateTransformElement where
-  toJSVal = return . unSVGAnimateTransformElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SVGAnimateTransformElement where
-  fromJSVal = return . fmap SVGAnimateTransformElement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsSVGAnimationElement SVGAnimateTransformElement
-instance IsSVGElement SVGAnimateTransformElement
-instance IsElement SVGAnimateTransformElement
-instance IsNode SVGAnimateTransformElement
-instance IsEventTarget SVGAnimateTransformElement
-instance IsGObject SVGAnimateTransformElement where
-  toGObject = GObject . unSVGAnimateTransformElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SVGAnimateTransformElement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSVGAnimateTransformElement :: IsGObject obj => obj -> IO SVGAnimateTransformElement
-castToSVGAnimateTransformElement = castTo gTypeSVGAnimateTransformElement "SVGAnimateTransformElement"
-
-foreign import javascript unsafe "window[\"SVGAnimateTransformElement\"]" gTypeSVGAnimateTransformElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SVGAnimatedAngle".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SVGAnimatedAngle Mozilla SVGAnimatedAngle documentation>
-newtype SVGAnimatedAngle = SVGAnimatedAngle { unSVGAnimatedAngle :: JSVal }
-
-instance Eq (SVGAnimatedAngle) where
-  (SVGAnimatedAngle a) == (SVGAnimatedAngle b) = js_eq a b
-
-instance PToJSVal SVGAnimatedAngle where
-  pToJSVal = unSVGAnimatedAngle
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SVGAnimatedAngle where
-  pFromJSVal = SVGAnimatedAngle
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SVGAnimatedAngle where
-  toJSVal = return . unSVGAnimatedAngle
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SVGAnimatedAngle where
-  fromJSVal = return . fmap SVGAnimatedAngle . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject SVGAnimatedAngle where
-  toGObject = GObject . unSVGAnimatedAngle
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SVGAnimatedAngle . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSVGAnimatedAngle :: IsGObject obj => obj -> IO SVGAnimatedAngle
-castToSVGAnimatedAngle = castTo gTypeSVGAnimatedAngle "SVGAnimatedAngle"
-
-foreign import javascript unsafe "window[\"SVGAnimatedAngle\"]" gTypeSVGAnimatedAngle :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SVGAnimatedBoolean".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SVGAnimatedBoolean Mozilla SVGAnimatedBoolean documentation>
-newtype SVGAnimatedBoolean = SVGAnimatedBoolean { unSVGAnimatedBoolean :: JSVal }
-
-instance Eq (SVGAnimatedBoolean) where
-  (SVGAnimatedBoolean a) == (SVGAnimatedBoolean b) = js_eq a b
-
-instance PToJSVal SVGAnimatedBoolean where
-  pToJSVal = unSVGAnimatedBoolean
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SVGAnimatedBoolean where
-  pFromJSVal = SVGAnimatedBoolean
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SVGAnimatedBoolean where
-  toJSVal = return . unSVGAnimatedBoolean
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SVGAnimatedBoolean where
-  fromJSVal = return . fmap SVGAnimatedBoolean . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject SVGAnimatedBoolean where
-  toGObject = GObject . unSVGAnimatedBoolean
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SVGAnimatedBoolean . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSVGAnimatedBoolean :: IsGObject obj => obj -> IO SVGAnimatedBoolean
-castToSVGAnimatedBoolean = castTo gTypeSVGAnimatedBoolean "SVGAnimatedBoolean"
-
-foreign import javascript unsafe "window[\"SVGAnimatedBoolean\"]" gTypeSVGAnimatedBoolean :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SVGAnimatedEnumeration".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SVGAnimatedEnumeration Mozilla SVGAnimatedEnumeration documentation>
-newtype SVGAnimatedEnumeration = SVGAnimatedEnumeration { unSVGAnimatedEnumeration :: JSVal }
-
-instance Eq (SVGAnimatedEnumeration) where
-  (SVGAnimatedEnumeration a) == (SVGAnimatedEnumeration b) = js_eq a b
-
-instance PToJSVal SVGAnimatedEnumeration where
-  pToJSVal = unSVGAnimatedEnumeration
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SVGAnimatedEnumeration where
-  pFromJSVal = SVGAnimatedEnumeration
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SVGAnimatedEnumeration where
-  toJSVal = return . unSVGAnimatedEnumeration
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SVGAnimatedEnumeration where
-  fromJSVal = return . fmap SVGAnimatedEnumeration . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject SVGAnimatedEnumeration where
-  toGObject = GObject . unSVGAnimatedEnumeration
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SVGAnimatedEnumeration . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSVGAnimatedEnumeration :: IsGObject obj => obj -> IO SVGAnimatedEnumeration
-castToSVGAnimatedEnumeration = castTo gTypeSVGAnimatedEnumeration "SVGAnimatedEnumeration"
-
-foreign import javascript unsafe "window[\"SVGAnimatedEnumeration\"]" gTypeSVGAnimatedEnumeration :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SVGAnimatedInteger".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SVGAnimatedInteger Mozilla SVGAnimatedInteger documentation>
-newtype SVGAnimatedInteger = SVGAnimatedInteger { unSVGAnimatedInteger :: JSVal }
-
-instance Eq (SVGAnimatedInteger) where
-  (SVGAnimatedInteger a) == (SVGAnimatedInteger b) = js_eq a b
-
-instance PToJSVal SVGAnimatedInteger where
-  pToJSVal = unSVGAnimatedInteger
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SVGAnimatedInteger where
-  pFromJSVal = SVGAnimatedInteger
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SVGAnimatedInteger where
-  toJSVal = return . unSVGAnimatedInteger
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SVGAnimatedInteger where
-  fromJSVal = return . fmap SVGAnimatedInteger . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject SVGAnimatedInteger where
-  toGObject = GObject . unSVGAnimatedInteger
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SVGAnimatedInteger . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSVGAnimatedInteger :: IsGObject obj => obj -> IO SVGAnimatedInteger
-castToSVGAnimatedInteger = castTo gTypeSVGAnimatedInteger "SVGAnimatedInteger"
-
-foreign import javascript unsafe "window[\"SVGAnimatedInteger\"]" gTypeSVGAnimatedInteger :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SVGAnimatedLength".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SVGAnimatedLength Mozilla SVGAnimatedLength documentation>
-newtype SVGAnimatedLength = SVGAnimatedLength { unSVGAnimatedLength :: JSVal }
-
-instance Eq (SVGAnimatedLength) where
-  (SVGAnimatedLength a) == (SVGAnimatedLength b) = js_eq a b
-
-instance PToJSVal SVGAnimatedLength where
-  pToJSVal = unSVGAnimatedLength
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SVGAnimatedLength where
-  pFromJSVal = SVGAnimatedLength
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SVGAnimatedLength where
-  toJSVal = return . unSVGAnimatedLength
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SVGAnimatedLength where
-  fromJSVal = return . fmap SVGAnimatedLength . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject SVGAnimatedLength where
-  toGObject = GObject . unSVGAnimatedLength
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SVGAnimatedLength . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSVGAnimatedLength :: IsGObject obj => obj -> IO SVGAnimatedLength
-castToSVGAnimatedLength = castTo gTypeSVGAnimatedLength "SVGAnimatedLength"
-
-foreign import javascript unsafe "window[\"SVGAnimatedLength\"]" gTypeSVGAnimatedLength :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SVGAnimatedLengthList".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SVGAnimatedLengthList Mozilla SVGAnimatedLengthList documentation>
-newtype SVGAnimatedLengthList = SVGAnimatedLengthList { unSVGAnimatedLengthList :: JSVal }
-
-instance Eq (SVGAnimatedLengthList) where
-  (SVGAnimatedLengthList a) == (SVGAnimatedLengthList b) = js_eq a b
-
-instance PToJSVal SVGAnimatedLengthList where
-  pToJSVal = unSVGAnimatedLengthList
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SVGAnimatedLengthList where
-  pFromJSVal = SVGAnimatedLengthList
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SVGAnimatedLengthList where
-  toJSVal = return . unSVGAnimatedLengthList
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SVGAnimatedLengthList where
-  fromJSVal = return . fmap SVGAnimatedLengthList . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject SVGAnimatedLengthList where
-  toGObject = GObject . unSVGAnimatedLengthList
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SVGAnimatedLengthList . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSVGAnimatedLengthList :: IsGObject obj => obj -> IO SVGAnimatedLengthList
-castToSVGAnimatedLengthList = castTo gTypeSVGAnimatedLengthList "SVGAnimatedLengthList"
-
-foreign import javascript unsafe "window[\"SVGAnimatedLengthList\"]" gTypeSVGAnimatedLengthList :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SVGAnimatedNumber".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SVGAnimatedNumber Mozilla SVGAnimatedNumber documentation>
-newtype SVGAnimatedNumber = SVGAnimatedNumber { unSVGAnimatedNumber :: JSVal }
-
-instance Eq (SVGAnimatedNumber) where
-  (SVGAnimatedNumber a) == (SVGAnimatedNumber b) = js_eq a b
-
-instance PToJSVal SVGAnimatedNumber where
-  pToJSVal = unSVGAnimatedNumber
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SVGAnimatedNumber where
-  pFromJSVal = SVGAnimatedNumber
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SVGAnimatedNumber where
-  toJSVal = return . unSVGAnimatedNumber
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SVGAnimatedNumber where
-  fromJSVal = return . fmap SVGAnimatedNumber . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject SVGAnimatedNumber where
-  toGObject = GObject . unSVGAnimatedNumber
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SVGAnimatedNumber . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSVGAnimatedNumber :: IsGObject obj => obj -> IO SVGAnimatedNumber
-castToSVGAnimatedNumber = castTo gTypeSVGAnimatedNumber "SVGAnimatedNumber"
-
-foreign import javascript unsafe "window[\"SVGAnimatedNumber\"]" gTypeSVGAnimatedNumber :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SVGAnimatedNumberList".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SVGAnimatedNumberList Mozilla SVGAnimatedNumberList documentation>
-newtype SVGAnimatedNumberList = SVGAnimatedNumberList { unSVGAnimatedNumberList :: JSVal }
-
-instance Eq (SVGAnimatedNumberList) where
-  (SVGAnimatedNumberList a) == (SVGAnimatedNumberList b) = js_eq a b
-
-instance PToJSVal SVGAnimatedNumberList where
-  pToJSVal = unSVGAnimatedNumberList
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SVGAnimatedNumberList where
-  pFromJSVal = SVGAnimatedNumberList
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SVGAnimatedNumberList where
-  toJSVal = return . unSVGAnimatedNumberList
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SVGAnimatedNumberList where
-  fromJSVal = return . fmap SVGAnimatedNumberList . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject SVGAnimatedNumberList where
-  toGObject = GObject . unSVGAnimatedNumberList
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SVGAnimatedNumberList . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSVGAnimatedNumberList :: IsGObject obj => obj -> IO SVGAnimatedNumberList
-castToSVGAnimatedNumberList = castTo gTypeSVGAnimatedNumberList "SVGAnimatedNumberList"
-
-foreign import javascript unsafe "window[\"SVGAnimatedNumberList\"]" gTypeSVGAnimatedNumberList :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SVGAnimatedPreserveAspectRatio".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SVGAnimatedPreserveAspectRatio Mozilla SVGAnimatedPreserveAspectRatio documentation>
-newtype SVGAnimatedPreserveAspectRatio = SVGAnimatedPreserveAspectRatio { unSVGAnimatedPreserveAspectRatio :: JSVal }
-
-instance Eq (SVGAnimatedPreserveAspectRatio) where
-  (SVGAnimatedPreserveAspectRatio a) == (SVGAnimatedPreserveAspectRatio b) = js_eq a b
-
-instance PToJSVal SVGAnimatedPreserveAspectRatio where
-  pToJSVal = unSVGAnimatedPreserveAspectRatio
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SVGAnimatedPreserveAspectRatio where
-  pFromJSVal = SVGAnimatedPreserveAspectRatio
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SVGAnimatedPreserveAspectRatio where
-  toJSVal = return . unSVGAnimatedPreserveAspectRatio
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SVGAnimatedPreserveAspectRatio where
-  fromJSVal = return . fmap SVGAnimatedPreserveAspectRatio . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject SVGAnimatedPreserveAspectRatio where
-  toGObject = GObject . unSVGAnimatedPreserveAspectRatio
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SVGAnimatedPreserveAspectRatio . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSVGAnimatedPreserveAspectRatio :: IsGObject obj => obj -> IO SVGAnimatedPreserveAspectRatio
-castToSVGAnimatedPreserveAspectRatio = castTo gTypeSVGAnimatedPreserveAspectRatio "SVGAnimatedPreserveAspectRatio"
-
-foreign import javascript unsafe "window[\"SVGAnimatedPreserveAspectRatio\"]" gTypeSVGAnimatedPreserveAspectRatio :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SVGAnimatedRect".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SVGAnimatedRect Mozilla SVGAnimatedRect documentation>
-newtype SVGAnimatedRect = SVGAnimatedRect { unSVGAnimatedRect :: JSVal }
-
-instance Eq (SVGAnimatedRect) where
-  (SVGAnimatedRect a) == (SVGAnimatedRect b) = js_eq a b
-
-instance PToJSVal SVGAnimatedRect where
-  pToJSVal = unSVGAnimatedRect
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SVGAnimatedRect where
-  pFromJSVal = SVGAnimatedRect
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SVGAnimatedRect where
-  toJSVal = return . unSVGAnimatedRect
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SVGAnimatedRect where
-  fromJSVal = return . fmap SVGAnimatedRect . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject SVGAnimatedRect where
-  toGObject = GObject . unSVGAnimatedRect
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SVGAnimatedRect . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSVGAnimatedRect :: IsGObject obj => obj -> IO SVGAnimatedRect
-castToSVGAnimatedRect = castTo gTypeSVGAnimatedRect "SVGAnimatedRect"
-
-foreign import javascript unsafe "window[\"SVGAnimatedRect\"]" gTypeSVGAnimatedRect :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SVGAnimatedString".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SVGAnimatedString Mozilla SVGAnimatedString documentation>
-newtype SVGAnimatedString = SVGAnimatedString { unSVGAnimatedString :: JSVal }
-
-instance Eq (SVGAnimatedString) where
-  (SVGAnimatedString a) == (SVGAnimatedString b) = js_eq a b
-
-instance PToJSVal SVGAnimatedString where
-  pToJSVal = unSVGAnimatedString
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SVGAnimatedString where
-  pFromJSVal = SVGAnimatedString
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SVGAnimatedString where
-  toJSVal = return . unSVGAnimatedString
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SVGAnimatedString where
-  fromJSVal = return . fmap SVGAnimatedString . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject SVGAnimatedString where
-  toGObject = GObject . unSVGAnimatedString
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SVGAnimatedString . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSVGAnimatedString :: IsGObject obj => obj -> IO SVGAnimatedString
-castToSVGAnimatedString = castTo gTypeSVGAnimatedString "SVGAnimatedString"
-
-foreign import javascript unsafe "window[\"SVGAnimatedString\"]" gTypeSVGAnimatedString :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SVGAnimatedTransformList".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SVGAnimatedTransformList Mozilla SVGAnimatedTransformList documentation>
-newtype SVGAnimatedTransformList = SVGAnimatedTransformList { unSVGAnimatedTransformList :: JSVal }
-
-instance Eq (SVGAnimatedTransformList) where
-  (SVGAnimatedTransformList a) == (SVGAnimatedTransformList b) = js_eq a b
-
-instance PToJSVal SVGAnimatedTransformList where
-  pToJSVal = unSVGAnimatedTransformList
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SVGAnimatedTransformList where
-  pFromJSVal = SVGAnimatedTransformList
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SVGAnimatedTransformList where
-  toJSVal = return . unSVGAnimatedTransformList
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SVGAnimatedTransformList where
-  fromJSVal = return . fmap SVGAnimatedTransformList . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject SVGAnimatedTransformList where
-  toGObject = GObject . unSVGAnimatedTransformList
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SVGAnimatedTransformList . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSVGAnimatedTransformList :: IsGObject obj => obj -> IO SVGAnimatedTransformList
-castToSVGAnimatedTransformList = castTo gTypeSVGAnimatedTransformList "SVGAnimatedTransformList"
-
-foreign import javascript unsafe "window[\"SVGAnimatedTransformList\"]" gTypeSVGAnimatedTransformList :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SVGAnimationElement".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.SVGElement"
---     * "GHCJS.DOM.Element"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SVGAnimationElement Mozilla SVGAnimationElement documentation>
-newtype SVGAnimationElement = SVGAnimationElement { unSVGAnimationElement :: JSVal }
-
-instance Eq (SVGAnimationElement) where
-  (SVGAnimationElement a) == (SVGAnimationElement b) = js_eq a b
-
-instance PToJSVal SVGAnimationElement where
-  pToJSVal = unSVGAnimationElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SVGAnimationElement where
-  pFromJSVal = SVGAnimationElement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SVGAnimationElement where
-  toJSVal = return . unSVGAnimationElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SVGAnimationElement where
-  fromJSVal = return . fmap SVGAnimationElement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-class IsSVGElement o => IsSVGAnimationElement o
-toSVGAnimationElement :: IsSVGAnimationElement o => o -> SVGAnimationElement
-toSVGAnimationElement = unsafeCastGObject . toGObject
-
-instance IsSVGAnimationElement SVGAnimationElement
-instance IsSVGElement SVGAnimationElement
-instance IsElement SVGAnimationElement
-instance IsNode SVGAnimationElement
-instance IsEventTarget SVGAnimationElement
-instance IsGObject SVGAnimationElement where
-  toGObject = GObject . unSVGAnimationElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SVGAnimationElement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSVGAnimationElement :: IsGObject obj => obj -> IO SVGAnimationElement
-castToSVGAnimationElement = castTo gTypeSVGAnimationElement "SVGAnimationElement"
-
-foreign import javascript unsafe "window[\"SVGAnimationElement\"]" gTypeSVGAnimationElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SVGCircleElement".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.SVGGraphicsElement"
---     * "GHCJS.DOM.SVGElement"
---     * "GHCJS.DOM.Element"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SVGCircleElement Mozilla SVGCircleElement documentation>
-newtype SVGCircleElement = SVGCircleElement { unSVGCircleElement :: JSVal }
-
-instance Eq (SVGCircleElement) where
-  (SVGCircleElement a) == (SVGCircleElement b) = js_eq a b
-
-instance PToJSVal SVGCircleElement where
-  pToJSVal = unSVGCircleElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SVGCircleElement where
-  pFromJSVal = SVGCircleElement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SVGCircleElement where
-  toJSVal = return . unSVGCircleElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SVGCircleElement where
-  fromJSVal = return . fmap SVGCircleElement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsSVGGraphicsElement SVGCircleElement
-instance IsSVGElement SVGCircleElement
-instance IsElement SVGCircleElement
-instance IsNode SVGCircleElement
-instance IsEventTarget SVGCircleElement
-instance IsGObject SVGCircleElement where
-  toGObject = GObject . unSVGCircleElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SVGCircleElement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSVGCircleElement :: IsGObject obj => obj -> IO SVGCircleElement
-castToSVGCircleElement = castTo gTypeSVGCircleElement "SVGCircleElement"
-
-foreign import javascript unsafe "window[\"SVGCircleElement\"]" gTypeSVGCircleElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SVGClipPathElement".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.SVGGraphicsElement"
---     * "GHCJS.DOM.SVGElement"
---     * "GHCJS.DOM.Element"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SVGClipPathElement Mozilla SVGClipPathElement documentation>
-newtype SVGClipPathElement = SVGClipPathElement { unSVGClipPathElement :: JSVal }
-
-instance Eq (SVGClipPathElement) where
-  (SVGClipPathElement a) == (SVGClipPathElement b) = js_eq a b
-
-instance PToJSVal SVGClipPathElement where
-  pToJSVal = unSVGClipPathElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SVGClipPathElement where
-  pFromJSVal = SVGClipPathElement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SVGClipPathElement where
-  toJSVal = return . unSVGClipPathElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SVGClipPathElement where
-  fromJSVal = return . fmap SVGClipPathElement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsSVGGraphicsElement SVGClipPathElement
-instance IsSVGElement SVGClipPathElement
-instance IsElement SVGClipPathElement
-instance IsNode SVGClipPathElement
-instance IsEventTarget SVGClipPathElement
-instance IsGObject SVGClipPathElement where
-  toGObject = GObject . unSVGClipPathElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SVGClipPathElement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSVGClipPathElement :: IsGObject obj => obj -> IO SVGClipPathElement
-castToSVGClipPathElement = castTo gTypeSVGClipPathElement "SVGClipPathElement"
-
-foreign import javascript unsafe "window[\"SVGClipPathElement\"]" gTypeSVGClipPathElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SVGColor".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.CSSValue"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SVGColor Mozilla SVGColor documentation>
-newtype SVGColor = SVGColor { unSVGColor :: JSVal }
-
-instance Eq (SVGColor) where
-  (SVGColor a) == (SVGColor b) = js_eq a b
-
-instance PToJSVal SVGColor where
-  pToJSVal = unSVGColor
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SVGColor where
-  pFromJSVal = SVGColor
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SVGColor where
-  toJSVal = return . unSVGColor
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SVGColor where
-  fromJSVal = return . fmap SVGColor . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-class IsCSSValue o => IsSVGColor o
-toSVGColor :: IsSVGColor o => o -> SVGColor
-toSVGColor = unsafeCastGObject . toGObject
-
-instance IsSVGColor SVGColor
-instance IsCSSValue SVGColor
-instance IsGObject SVGColor where
-  toGObject = GObject . unSVGColor
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SVGColor . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSVGColor :: IsGObject obj => obj -> IO SVGColor
-castToSVGColor = castTo gTypeSVGColor "SVGColor"
-
-foreign import javascript unsafe "window[\"SVGColor\"]" gTypeSVGColor :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SVGComponentTransferFunctionElement".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.SVGElement"
---     * "GHCJS.DOM.Element"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SVGComponentTransferFunctionElement Mozilla SVGComponentTransferFunctionElement documentation>
-newtype SVGComponentTransferFunctionElement = SVGComponentTransferFunctionElement { unSVGComponentTransferFunctionElement :: JSVal }
-
-instance Eq (SVGComponentTransferFunctionElement) where
-  (SVGComponentTransferFunctionElement a) == (SVGComponentTransferFunctionElement b) = js_eq a b
-
-instance PToJSVal SVGComponentTransferFunctionElement where
-  pToJSVal = unSVGComponentTransferFunctionElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SVGComponentTransferFunctionElement where
-  pFromJSVal = SVGComponentTransferFunctionElement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SVGComponentTransferFunctionElement where
-  toJSVal = return . unSVGComponentTransferFunctionElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SVGComponentTransferFunctionElement where
-  fromJSVal = return . fmap SVGComponentTransferFunctionElement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-class IsSVGElement o => IsSVGComponentTransferFunctionElement o
-toSVGComponentTransferFunctionElement :: IsSVGComponentTransferFunctionElement o => o -> SVGComponentTransferFunctionElement
-toSVGComponentTransferFunctionElement = unsafeCastGObject . toGObject
-
-instance IsSVGComponentTransferFunctionElement SVGComponentTransferFunctionElement
-instance IsSVGElement SVGComponentTransferFunctionElement
-instance IsElement SVGComponentTransferFunctionElement
-instance IsNode SVGComponentTransferFunctionElement
-instance IsEventTarget SVGComponentTransferFunctionElement
-instance IsGObject SVGComponentTransferFunctionElement where
-  toGObject = GObject . unSVGComponentTransferFunctionElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SVGComponentTransferFunctionElement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSVGComponentTransferFunctionElement :: IsGObject obj => obj -> IO SVGComponentTransferFunctionElement
-castToSVGComponentTransferFunctionElement = castTo gTypeSVGComponentTransferFunctionElement "SVGComponentTransferFunctionElement"
-
-foreign import javascript unsafe "window[\"SVGComponentTransferFunctionElement\"]" gTypeSVGComponentTransferFunctionElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SVGCursorElement".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.SVGElement"
---     * "GHCJS.DOM.Element"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SVGCursorElement Mozilla SVGCursorElement documentation>
-newtype SVGCursorElement = SVGCursorElement { unSVGCursorElement :: JSVal }
-
-instance Eq (SVGCursorElement) where
-  (SVGCursorElement a) == (SVGCursorElement b) = js_eq a b
-
-instance PToJSVal SVGCursorElement where
-  pToJSVal = unSVGCursorElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SVGCursorElement where
-  pFromJSVal = SVGCursorElement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SVGCursorElement where
-  toJSVal = return . unSVGCursorElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SVGCursorElement where
-  fromJSVal = return . fmap SVGCursorElement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsSVGElement SVGCursorElement
-instance IsElement SVGCursorElement
-instance IsNode SVGCursorElement
-instance IsEventTarget SVGCursorElement
-instance IsGObject SVGCursorElement where
-  toGObject = GObject . unSVGCursorElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SVGCursorElement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSVGCursorElement :: IsGObject obj => obj -> IO SVGCursorElement
-castToSVGCursorElement = castTo gTypeSVGCursorElement "SVGCursorElement"
-
-foreign import javascript unsafe "window[\"SVGCursorElement\"]" gTypeSVGCursorElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SVGDefsElement".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.SVGGraphicsElement"
---     * "GHCJS.DOM.SVGElement"
---     * "GHCJS.DOM.Element"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SVGDefsElement Mozilla SVGDefsElement documentation>
-newtype SVGDefsElement = SVGDefsElement { unSVGDefsElement :: JSVal }
-
-instance Eq (SVGDefsElement) where
-  (SVGDefsElement a) == (SVGDefsElement b) = js_eq a b
-
-instance PToJSVal SVGDefsElement where
-  pToJSVal = unSVGDefsElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SVGDefsElement where
-  pFromJSVal = SVGDefsElement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SVGDefsElement where
-  toJSVal = return . unSVGDefsElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SVGDefsElement where
-  fromJSVal = return . fmap SVGDefsElement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsSVGGraphicsElement SVGDefsElement
-instance IsSVGElement SVGDefsElement
-instance IsElement SVGDefsElement
-instance IsNode SVGDefsElement
-instance IsEventTarget SVGDefsElement
-instance IsGObject SVGDefsElement where
-  toGObject = GObject . unSVGDefsElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SVGDefsElement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSVGDefsElement :: IsGObject obj => obj -> IO SVGDefsElement
-castToSVGDefsElement = castTo gTypeSVGDefsElement "SVGDefsElement"
-
-foreign import javascript unsafe "window[\"SVGDefsElement\"]" gTypeSVGDefsElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SVGDescElement".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.SVGElement"
---     * "GHCJS.DOM.Element"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SVGDescElement Mozilla SVGDescElement documentation>
-newtype SVGDescElement = SVGDescElement { unSVGDescElement :: JSVal }
-
-instance Eq (SVGDescElement) where
-  (SVGDescElement a) == (SVGDescElement b) = js_eq a b
-
-instance PToJSVal SVGDescElement where
-  pToJSVal = unSVGDescElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SVGDescElement where
-  pFromJSVal = SVGDescElement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SVGDescElement where
-  toJSVal = return . unSVGDescElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SVGDescElement where
-  fromJSVal = return . fmap SVGDescElement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsSVGElement SVGDescElement
-instance IsElement SVGDescElement
-instance IsNode SVGDescElement
-instance IsEventTarget SVGDescElement
-instance IsGObject SVGDescElement where
-  toGObject = GObject . unSVGDescElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SVGDescElement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSVGDescElement :: IsGObject obj => obj -> IO SVGDescElement
-castToSVGDescElement = castTo gTypeSVGDescElement "SVGDescElement"
-
-foreign import javascript unsafe "window[\"SVGDescElement\"]" gTypeSVGDescElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SVGDocument".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.Document"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SVGDocument Mozilla SVGDocument documentation>
-newtype SVGDocument = SVGDocument { unSVGDocument :: JSVal }
-
-instance Eq (SVGDocument) where
-  (SVGDocument a) == (SVGDocument b) = js_eq a b
-
-instance PToJSVal SVGDocument where
-  pToJSVal = unSVGDocument
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SVGDocument where
-  pFromJSVal = SVGDocument
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SVGDocument where
-  toJSVal = return . unSVGDocument
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SVGDocument where
-  fromJSVal = return . fmap SVGDocument . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsDocument SVGDocument
-instance IsNode SVGDocument
-instance IsEventTarget SVGDocument
-instance IsGObject SVGDocument where
-  toGObject = GObject . unSVGDocument
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SVGDocument . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSVGDocument :: IsGObject obj => obj -> IO SVGDocument
-castToSVGDocument = castTo gTypeSVGDocument "SVGDocument"
-
-foreign import javascript unsafe "window[\"SVGDocument\"]" gTypeSVGDocument :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SVGElement".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.Element"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SVGElement Mozilla SVGElement documentation>
-newtype SVGElement = SVGElement { unSVGElement :: JSVal }
-
-instance Eq (SVGElement) where
-  (SVGElement a) == (SVGElement b) = js_eq a b
-
-instance PToJSVal SVGElement where
-  pToJSVal = unSVGElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SVGElement where
-  pFromJSVal = SVGElement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SVGElement where
-  toJSVal = return . unSVGElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SVGElement where
-  fromJSVal = return . fmap SVGElement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-class IsElement o => IsSVGElement o
-toSVGElement :: IsSVGElement o => o -> SVGElement
-toSVGElement = unsafeCastGObject . toGObject
-
-instance IsSVGElement SVGElement
-instance IsElement SVGElement
-instance IsNode SVGElement
-instance IsEventTarget SVGElement
-instance IsGObject SVGElement where
-  toGObject = GObject . unSVGElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SVGElement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSVGElement :: IsGObject obj => obj -> IO SVGElement
-castToSVGElement = castTo gTypeSVGElement "SVGElement"
-
-foreign import javascript unsafe "window[\"SVGElement\"]" gTypeSVGElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SVGEllipseElement".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.SVGGraphicsElement"
---     * "GHCJS.DOM.SVGElement"
---     * "GHCJS.DOM.Element"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SVGEllipseElement Mozilla SVGEllipseElement documentation>
-newtype SVGEllipseElement = SVGEllipseElement { unSVGEllipseElement :: JSVal }
-
-instance Eq (SVGEllipseElement) where
-  (SVGEllipseElement a) == (SVGEllipseElement b) = js_eq a b
-
-instance PToJSVal SVGEllipseElement where
-  pToJSVal = unSVGEllipseElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SVGEllipseElement where
-  pFromJSVal = SVGEllipseElement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SVGEllipseElement where
-  toJSVal = return . unSVGEllipseElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SVGEllipseElement where
-  fromJSVal = return . fmap SVGEllipseElement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsSVGGraphicsElement SVGEllipseElement
-instance IsSVGElement SVGEllipseElement
-instance IsElement SVGEllipseElement
-instance IsNode SVGEllipseElement
-instance IsEventTarget SVGEllipseElement
-instance IsGObject SVGEllipseElement where
-  toGObject = GObject . unSVGEllipseElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SVGEllipseElement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSVGEllipseElement :: IsGObject obj => obj -> IO SVGEllipseElement
-castToSVGEllipseElement = castTo gTypeSVGEllipseElement "SVGEllipseElement"
-
-foreign import javascript unsafe "window[\"SVGEllipseElement\"]" gTypeSVGEllipseElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SVGExternalResourcesRequired".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SVGExternalResourcesRequired Mozilla SVGExternalResourcesRequired documentation>
-newtype SVGExternalResourcesRequired = SVGExternalResourcesRequired { unSVGExternalResourcesRequired :: JSVal }
-
-instance Eq (SVGExternalResourcesRequired) where
-  (SVGExternalResourcesRequired a) == (SVGExternalResourcesRequired b) = js_eq a b
-
-instance PToJSVal SVGExternalResourcesRequired where
-  pToJSVal = unSVGExternalResourcesRequired
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SVGExternalResourcesRequired where
-  pFromJSVal = SVGExternalResourcesRequired
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SVGExternalResourcesRequired where
-  toJSVal = return . unSVGExternalResourcesRequired
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SVGExternalResourcesRequired where
-  fromJSVal = return . fmap SVGExternalResourcesRequired . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject SVGExternalResourcesRequired where
-  toGObject = GObject . unSVGExternalResourcesRequired
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SVGExternalResourcesRequired . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSVGExternalResourcesRequired :: IsGObject obj => obj -> IO SVGExternalResourcesRequired
-castToSVGExternalResourcesRequired = castTo gTypeSVGExternalResourcesRequired "SVGExternalResourcesRequired"
-
-foreign import javascript unsafe "window[\"SVGExternalResourcesRequired\"]" gTypeSVGExternalResourcesRequired :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SVGFEBlendElement".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.SVGElement"
---     * "GHCJS.DOM.Element"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SVGFEBlendElement Mozilla SVGFEBlendElement documentation>
-newtype SVGFEBlendElement = SVGFEBlendElement { unSVGFEBlendElement :: JSVal }
-
-instance Eq (SVGFEBlendElement) where
-  (SVGFEBlendElement a) == (SVGFEBlendElement b) = js_eq a b
-
-instance PToJSVal SVGFEBlendElement where
-  pToJSVal = unSVGFEBlendElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SVGFEBlendElement where
-  pFromJSVal = SVGFEBlendElement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SVGFEBlendElement where
-  toJSVal = return . unSVGFEBlendElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SVGFEBlendElement where
-  fromJSVal = return . fmap SVGFEBlendElement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsSVGElement SVGFEBlendElement
-instance IsElement SVGFEBlendElement
-instance IsNode SVGFEBlendElement
-instance IsEventTarget SVGFEBlendElement
-instance IsGObject SVGFEBlendElement where
-  toGObject = GObject . unSVGFEBlendElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SVGFEBlendElement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSVGFEBlendElement :: IsGObject obj => obj -> IO SVGFEBlendElement
-castToSVGFEBlendElement = castTo gTypeSVGFEBlendElement "SVGFEBlendElement"
-
-foreign import javascript unsafe "window[\"SVGFEBlendElement\"]" gTypeSVGFEBlendElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SVGFEColorMatrixElement".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.SVGElement"
---     * "GHCJS.DOM.Element"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SVGFEColorMatrixElement Mozilla SVGFEColorMatrixElement documentation>
-newtype SVGFEColorMatrixElement = SVGFEColorMatrixElement { unSVGFEColorMatrixElement :: JSVal }
-
-instance Eq (SVGFEColorMatrixElement) where
-  (SVGFEColorMatrixElement a) == (SVGFEColorMatrixElement b) = js_eq a b
-
-instance PToJSVal SVGFEColorMatrixElement where
-  pToJSVal = unSVGFEColorMatrixElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SVGFEColorMatrixElement where
-  pFromJSVal = SVGFEColorMatrixElement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SVGFEColorMatrixElement where
-  toJSVal = return . unSVGFEColorMatrixElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SVGFEColorMatrixElement where
-  fromJSVal = return . fmap SVGFEColorMatrixElement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsSVGElement SVGFEColorMatrixElement
-instance IsElement SVGFEColorMatrixElement
-instance IsNode SVGFEColorMatrixElement
-instance IsEventTarget SVGFEColorMatrixElement
-instance IsGObject SVGFEColorMatrixElement where
-  toGObject = GObject . unSVGFEColorMatrixElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SVGFEColorMatrixElement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSVGFEColorMatrixElement :: IsGObject obj => obj -> IO SVGFEColorMatrixElement
-castToSVGFEColorMatrixElement = castTo gTypeSVGFEColorMatrixElement "SVGFEColorMatrixElement"
-
-foreign import javascript unsafe "window[\"SVGFEColorMatrixElement\"]" gTypeSVGFEColorMatrixElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SVGFEComponentTransferElement".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.SVGElement"
---     * "GHCJS.DOM.Element"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SVGFEComponentTransferElement Mozilla SVGFEComponentTransferElement documentation>
-newtype SVGFEComponentTransferElement = SVGFEComponentTransferElement { unSVGFEComponentTransferElement :: JSVal }
-
-instance Eq (SVGFEComponentTransferElement) where
-  (SVGFEComponentTransferElement a) == (SVGFEComponentTransferElement b) = js_eq a b
-
-instance PToJSVal SVGFEComponentTransferElement where
-  pToJSVal = unSVGFEComponentTransferElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SVGFEComponentTransferElement where
-  pFromJSVal = SVGFEComponentTransferElement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SVGFEComponentTransferElement where
-  toJSVal = return . unSVGFEComponentTransferElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SVGFEComponentTransferElement where
-  fromJSVal = return . fmap SVGFEComponentTransferElement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsSVGElement SVGFEComponentTransferElement
-instance IsElement SVGFEComponentTransferElement
-instance IsNode SVGFEComponentTransferElement
-instance IsEventTarget SVGFEComponentTransferElement
-instance IsGObject SVGFEComponentTransferElement where
-  toGObject = GObject . unSVGFEComponentTransferElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SVGFEComponentTransferElement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSVGFEComponentTransferElement :: IsGObject obj => obj -> IO SVGFEComponentTransferElement
-castToSVGFEComponentTransferElement = castTo gTypeSVGFEComponentTransferElement "SVGFEComponentTransferElement"
-
-foreign import javascript unsafe "window[\"SVGFEComponentTransferElement\"]" gTypeSVGFEComponentTransferElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SVGFECompositeElement".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.SVGElement"
---     * "GHCJS.DOM.Element"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SVGFECompositeElement Mozilla SVGFECompositeElement documentation>
-newtype SVGFECompositeElement = SVGFECompositeElement { unSVGFECompositeElement :: JSVal }
-
-instance Eq (SVGFECompositeElement) where
-  (SVGFECompositeElement a) == (SVGFECompositeElement b) = js_eq a b
-
-instance PToJSVal SVGFECompositeElement where
-  pToJSVal = unSVGFECompositeElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SVGFECompositeElement where
-  pFromJSVal = SVGFECompositeElement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SVGFECompositeElement where
-  toJSVal = return . unSVGFECompositeElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SVGFECompositeElement where
-  fromJSVal = return . fmap SVGFECompositeElement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsSVGElement SVGFECompositeElement
-instance IsElement SVGFECompositeElement
-instance IsNode SVGFECompositeElement
-instance IsEventTarget SVGFECompositeElement
-instance IsGObject SVGFECompositeElement where
-  toGObject = GObject . unSVGFECompositeElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SVGFECompositeElement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSVGFECompositeElement :: IsGObject obj => obj -> IO SVGFECompositeElement
-castToSVGFECompositeElement = castTo gTypeSVGFECompositeElement "SVGFECompositeElement"
-
-foreign import javascript unsafe "window[\"SVGFECompositeElement\"]" gTypeSVGFECompositeElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SVGFEConvolveMatrixElement".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.SVGElement"
---     * "GHCJS.DOM.Element"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SVGFEConvolveMatrixElement Mozilla SVGFEConvolveMatrixElement documentation>
-newtype SVGFEConvolveMatrixElement = SVGFEConvolveMatrixElement { unSVGFEConvolveMatrixElement :: JSVal }
-
-instance Eq (SVGFEConvolveMatrixElement) where
-  (SVGFEConvolveMatrixElement a) == (SVGFEConvolveMatrixElement b) = js_eq a b
-
-instance PToJSVal SVGFEConvolveMatrixElement where
-  pToJSVal = unSVGFEConvolveMatrixElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SVGFEConvolveMatrixElement where
-  pFromJSVal = SVGFEConvolveMatrixElement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SVGFEConvolveMatrixElement where
-  toJSVal = return . unSVGFEConvolveMatrixElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SVGFEConvolveMatrixElement where
-  fromJSVal = return . fmap SVGFEConvolveMatrixElement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsSVGElement SVGFEConvolveMatrixElement
-instance IsElement SVGFEConvolveMatrixElement
-instance IsNode SVGFEConvolveMatrixElement
-instance IsEventTarget SVGFEConvolveMatrixElement
-instance IsGObject SVGFEConvolveMatrixElement where
-  toGObject = GObject . unSVGFEConvolveMatrixElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SVGFEConvolveMatrixElement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSVGFEConvolveMatrixElement :: IsGObject obj => obj -> IO SVGFEConvolveMatrixElement
-castToSVGFEConvolveMatrixElement = castTo gTypeSVGFEConvolveMatrixElement "SVGFEConvolveMatrixElement"
-
-foreign import javascript unsafe "window[\"SVGFEConvolveMatrixElement\"]" gTypeSVGFEConvolveMatrixElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SVGFEDiffuseLightingElement".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.SVGElement"
---     * "GHCJS.DOM.Element"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SVGFEDiffuseLightingElement Mozilla SVGFEDiffuseLightingElement documentation>
-newtype SVGFEDiffuseLightingElement = SVGFEDiffuseLightingElement { unSVGFEDiffuseLightingElement :: JSVal }
-
-instance Eq (SVGFEDiffuseLightingElement) where
-  (SVGFEDiffuseLightingElement a) == (SVGFEDiffuseLightingElement b) = js_eq a b
-
-instance PToJSVal SVGFEDiffuseLightingElement where
-  pToJSVal = unSVGFEDiffuseLightingElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SVGFEDiffuseLightingElement where
-  pFromJSVal = SVGFEDiffuseLightingElement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SVGFEDiffuseLightingElement where
-  toJSVal = return . unSVGFEDiffuseLightingElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SVGFEDiffuseLightingElement where
-  fromJSVal = return . fmap SVGFEDiffuseLightingElement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsSVGElement SVGFEDiffuseLightingElement
-instance IsElement SVGFEDiffuseLightingElement
-instance IsNode SVGFEDiffuseLightingElement
-instance IsEventTarget SVGFEDiffuseLightingElement
-instance IsGObject SVGFEDiffuseLightingElement where
-  toGObject = GObject . unSVGFEDiffuseLightingElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SVGFEDiffuseLightingElement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSVGFEDiffuseLightingElement :: IsGObject obj => obj -> IO SVGFEDiffuseLightingElement
-castToSVGFEDiffuseLightingElement = castTo gTypeSVGFEDiffuseLightingElement "SVGFEDiffuseLightingElement"
-
-foreign import javascript unsafe "window[\"SVGFEDiffuseLightingElement\"]" gTypeSVGFEDiffuseLightingElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SVGFEDisplacementMapElement".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.SVGElement"
---     * "GHCJS.DOM.Element"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SVGFEDisplacementMapElement Mozilla SVGFEDisplacementMapElement documentation>
-newtype SVGFEDisplacementMapElement = SVGFEDisplacementMapElement { unSVGFEDisplacementMapElement :: JSVal }
-
-instance Eq (SVGFEDisplacementMapElement) where
-  (SVGFEDisplacementMapElement a) == (SVGFEDisplacementMapElement b) = js_eq a b
-
-instance PToJSVal SVGFEDisplacementMapElement where
-  pToJSVal = unSVGFEDisplacementMapElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SVGFEDisplacementMapElement where
-  pFromJSVal = SVGFEDisplacementMapElement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SVGFEDisplacementMapElement where
-  toJSVal = return . unSVGFEDisplacementMapElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SVGFEDisplacementMapElement where
-  fromJSVal = return . fmap SVGFEDisplacementMapElement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsSVGElement SVGFEDisplacementMapElement
-instance IsElement SVGFEDisplacementMapElement
-instance IsNode SVGFEDisplacementMapElement
-instance IsEventTarget SVGFEDisplacementMapElement
-instance IsGObject SVGFEDisplacementMapElement where
-  toGObject = GObject . unSVGFEDisplacementMapElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SVGFEDisplacementMapElement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSVGFEDisplacementMapElement :: IsGObject obj => obj -> IO SVGFEDisplacementMapElement
-castToSVGFEDisplacementMapElement = castTo gTypeSVGFEDisplacementMapElement "SVGFEDisplacementMapElement"
-
-foreign import javascript unsafe "window[\"SVGFEDisplacementMapElement\"]" gTypeSVGFEDisplacementMapElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SVGFEDistantLightElement".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.SVGElement"
---     * "GHCJS.DOM.Element"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SVGFEDistantLightElement Mozilla SVGFEDistantLightElement documentation>
-newtype SVGFEDistantLightElement = SVGFEDistantLightElement { unSVGFEDistantLightElement :: JSVal }
-
-instance Eq (SVGFEDistantLightElement) where
-  (SVGFEDistantLightElement a) == (SVGFEDistantLightElement b) = js_eq a b
-
-instance PToJSVal SVGFEDistantLightElement where
-  pToJSVal = unSVGFEDistantLightElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SVGFEDistantLightElement where
-  pFromJSVal = SVGFEDistantLightElement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SVGFEDistantLightElement where
-  toJSVal = return . unSVGFEDistantLightElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SVGFEDistantLightElement where
-  fromJSVal = return . fmap SVGFEDistantLightElement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsSVGElement SVGFEDistantLightElement
-instance IsElement SVGFEDistantLightElement
-instance IsNode SVGFEDistantLightElement
-instance IsEventTarget SVGFEDistantLightElement
-instance IsGObject SVGFEDistantLightElement where
-  toGObject = GObject . unSVGFEDistantLightElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SVGFEDistantLightElement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSVGFEDistantLightElement :: IsGObject obj => obj -> IO SVGFEDistantLightElement
-castToSVGFEDistantLightElement = castTo gTypeSVGFEDistantLightElement "SVGFEDistantLightElement"
-
-foreign import javascript unsafe "window[\"SVGFEDistantLightElement\"]" gTypeSVGFEDistantLightElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SVGFEDropShadowElement".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.SVGElement"
---     * "GHCJS.DOM.Element"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SVGFEDropShadowElement Mozilla SVGFEDropShadowElement documentation>
-newtype SVGFEDropShadowElement = SVGFEDropShadowElement { unSVGFEDropShadowElement :: JSVal }
-
-instance Eq (SVGFEDropShadowElement) where
-  (SVGFEDropShadowElement a) == (SVGFEDropShadowElement b) = js_eq a b
-
-instance PToJSVal SVGFEDropShadowElement where
-  pToJSVal = unSVGFEDropShadowElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SVGFEDropShadowElement where
-  pFromJSVal = SVGFEDropShadowElement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SVGFEDropShadowElement where
-  toJSVal = return . unSVGFEDropShadowElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SVGFEDropShadowElement where
-  fromJSVal = return . fmap SVGFEDropShadowElement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsSVGElement SVGFEDropShadowElement
-instance IsElement SVGFEDropShadowElement
-instance IsNode SVGFEDropShadowElement
-instance IsEventTarget SVGFEDropShadowElement
-instance IsGObject SVGFEDropShadowElement where
-  toGObject = GObject . unSVGFEDropShadowElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SVGFEDropShadowElement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSVGFEDropShadowElement :: IsGObject obj => obj -> IO SVGFEDropShadowElement
-castToSVGFEDropShadowElement = castTo gTypeSVGFEDropShadowElement "SVGFEDropShadowElement"
-
-foreign import javascript unsafe "window[\"SVGFEDropShadowElement\"]" gTypeSVGFEDropShadowElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SVGFEFloodElement".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.SVGElement"
---     * "GHCJS.DOM.Element"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SVGFEFloodElement Mozilla SVGFEFloodElement documentation>
-newtype SVGFEFloodElement = SVGFEFloodElement { unSVGFEFloodElement :: JSVal }
-
-instance Eq (SVGFEFloodElement) where
-  (SVGFEFloodElement a) == (SVGFEFloodElement b) = js_eq a b
-
-instance PToJSVal SVGFEFloodElement where
-  pToJSVal = unSVGFEFloodElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SVGFEFloodElement where
-  pFromJSVal = SVGFEFloodElement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SVGFEFloodElement where
-  toJSVal = return . unSVGFEFloodElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SVGFEFloodElement where
-  fromJSVal = return . fmap SVGFEFloodElement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsSVGElement SVGFEFloodElement
-instance IsElement SVGFEFloodElement
-instance IsNode SVGFEFloodElement
-instance IsEventTarget SVGFEFloodElement
-instance IsGObject SVGFEFloodElement where
-  toGObject = GObject . unSVGFEFloodElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SVGFEFloodElement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSVGFEFloodElement :: IsGObject obj => obj -> IO SVGFEFloodElement
-castToSVGFEFloodElement = castTo gTypeSVGFEFloodElement "SVGFEFloodElement"
-
-foreign import javascript unsafe "window[\"SVGFEFloodElement\"]" gTypeSVGFEFloodElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SVGFEFuncAElement".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.SVGComponentTransferFunctionElement"
---     * "GHCJS.DOM.SVGElement"
---     * "GHCJS.DOM.Element"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SVGFEFuncAElement Mozilla SVGFEFuncAElement documentation>
-newtype SVGFEFuncAElement = SVGFEFuncAElement { unSVGFEFuncAElement :: JSVal }
-
-instance Eq (SVGFEFuncAElement) where
-  (SVGFEFuncAElement a) == (SVGFEFuncAElement b) = js_eq a b
-
-instance PToJSVal SVGFEFuncAElement where
-  pToJSVal = unSVGFEFuncAElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SVGFEFuncAElement where
-  pFromJSVal = SVGFEFuncAElement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SVGFEFuncAElement where
-  toJSVal = return . unSVGFEFuncAElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SVGFEFuncAElement where
-  fromJSVal = return . fmap SVGFEFuncAElement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsSVGComponentTransferFunctionElement SVGFEFuncAElement
-instance IsSVGElement SVGFEFuncAElement
-instance IsElement SVGFEFuncAElement
-instance IsNode SVGFEFuncAElement
-instance IsEventTarget SVGFEFuncAElement
-instance IsGObject SVGFEFuncAElement where
-  toGObject = GObject . unSVGFEFuncAElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SVGFEFuncAElement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSVGFEFuncAElement :: IsGObject obj => obj -> IO SVGFEFuncAElement
-castToSVGFEFuncAElement = castTo gTypeSVGFEFuncAElement "SVGFEFuncAElement"
-
-foreign import javascript unsafe "window[\"SVGFEFuncAElement\"]" gTypeSVGFEFuncAElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SVGFEFuncBElement".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.SVGComponentTransferFunctionElement"
---     * "GHCJS.DOM.SVGElement"
---     * "GHCJS.DOM.Element"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SVGFEFuncBElement Mozilla SVGFEFuncBElement documentation>
-newtype SVGFEFuncBElement = SVGFEFuncBElement { unSVGFEFuncBElement :: JSVal }
-
-instance Eq (SVGFEFuncBElement) where
-  (SVGFEFuncBElement a) == (SVGFEFuncBElement b) = js_eq a b
-
-instance PToJSVal SVGFEFuncBElement where
-  pToJSVal = unSVGFEFuncBElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SVGFEFuncBElement where
-  pFromJSVal = SVGFEFuncBElement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SVGFEFuncBElement where
-  toJSVal = return . unSVGFEFuncBElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SVGFEFuncBElement where
-  fromJSVal = return . fmap SVGFEFuncBElement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsSVGComponentTransferFunctionElement SVGFEFuncBElement
-instance IsSVGElement SVGFEFuncBElement
-instance IsElement SVGFEFuncBElement
-instance IsNode SVGFEFuncBElement
-instance IsEventTarget SVGFEFuncBElement
-instance IsGObject SVGFEFuncBElement where
-  toGObject = GObject . unSVGFEFuncBElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SVGFEFuncBElement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSVGFEFuncBElement :: IsGObject obj => obj -> IO SVGFEFuncBElement
-castToSVGFEFuncBElement = castTo gTypeSVGFEFuncBElement "SVGFEFuncBElement"
-
-foreign import javascript unsafe "window[\"SVGFEFuncBElement\"]" gTypeSVGFEFuncBElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SVGFEFuncGElement".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.SVGComponentTransferFunctionElement"
---     * "GHCJS.DOM.SVGElement"
---     * "GHCJS.DOM.Element"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SVGFEFuncGElement Mozilla SVGFEFuncGElement documentation>
-newtype SVGFEFuncGElement = SVGFEFuncGElement { unSVGFEFuncGElement :: JSVal }
-
-instance Eq (SVGFEFuncGElement) where
-  (SVGFEFuncGElement a) == (SVGFEFuncGElement b) = js_eq a b
-
-instance PToJSVal SVGFEFuncGElement where
-  pToJSVal = unSVGFEFuncGElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SVGFEFuncGElement where
-  pFromJSVal = SVGFEFuncGElement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SVGFEFuncGElement where
-  toJSVal = return . unSVGFEFuncGElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SVGFEFuncGElement where
-  fromJSVal = return . fmap SVGFEFuncGElement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsSVGComponentTransferFunctionElement SVGFEFuncGElement
-instance IsSVGElement SVGFEFuncGElement
-instance IsElement SVGFEFuncGElement
-instance IsNode SVGFEFuncGElement
-instance IsEventTarget SVGFEFuncGElement
-instance IsGObject SVGFEFuncGElement where
-  toGObject = GObject . unSVGFEFuncGElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SVGFEFuncGElement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSVGFEFuncGElement :: IsGObject obj => obj -> IO SVGFEFuncGElement
-castToSVGFEFuncGElement = castTo gTypeSVGFEFuncGElement "SVGFEFuncGElement"
-
-foreign import javascript unsafe "window[\"SVGFEFuncGElement\"]" gTypeSVGFEFuncGElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SVGFEFuncRElement".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.SVGComponentTransferFunctionElement"
---     * "GHCJS.DOM.SVGElement"
---     * "GHCJS.DOM.Element"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SVGFEFuncRElement Mozilla SVGFEFuncRElement documentation>
-newtype SVGFEFuncRElement = SVGFEFuncRElement { unSVGFEFuncRElement :: JSVal }
-
-instance Eq (SVGFEFuncRElement) where
-  (SVGFEFuncRElement a) == (SVGFEFuncRElement b) = js_eq a b
-
-instance PToJSVal SVGFEFuncRElement where
-  pToJSVal = unSVGFEFuncRElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SVGFEFuncRElement where
-  pFromJSVal = SVGFEFuncRElement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SVGFEFuncRElement where
-  toJSVal = return . unSVGFEFuncRElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SVGFEFuncRElement where
-  fromJSVal = return . fmap SVGFEFuncRElement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsSVGComponentTransferFunctionElement SVGFEFuncRElement
-instance IsSVGElement SVGFEFuncRElement
-instance IsElement SVGFEFuncRElement
-instance IsNode SVGFEFuncRElement
-instance IsEventTarget SVGFEFuncRElement
-instance IsGObject SVGFEFuncRElement where
-  toGObject = GObject . unSVGFEFuncRElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SVGFEFuncRElement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSVGFEFuncRElement :: IsGObject obj => obj -> IO SVGFEFuncRElement
-castToSVGFEFuncRElement = castTo gTypeSVGFEFuncRElement "SVGFEFuncRElement"
-
-foreign import javascript unsafe "window[\"SVGFEFuncRElement\"]" gTypeSVGFEFuncRElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SVGFEGaussianBlurElement".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.SVGElement"
---     * "GHCJS.DOM.Element"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SVGFEGaussianBlurElement Mozilla SVGFEGaussianBlurElement documentation>
-newtype SVGFEGaussianBlurElement = SVGFEGaussianBlurElement { unSVGFEGaussianBlurElement :: JSVal }
-
-instance Eq (SVGFEGaussianBlurElement) where
-  (SVGFEGaussianBlurElement a) == (SVGFEGaussianBlurElement b) = js_eq a b
-
-instance PToJSVal SVGFEGaussianBlurElement where
-  pToJSVal = unSVGFEGaussianBlurElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SVGFEGaussianBlurElement where
-  pFromJSVal = SVGFEGaussianBlurElement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SVGFEGaussianBlurElement where
-  toJSVal = return . unSVGFEGaussianBlurElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SVGFEGaussianBlurElement where
-  fromJSVal = return . fmap SVGFEGaussianBlurElement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsSVGElement SVGFEGaussianBlurElement
-instance IsElement SVGFEGaussianBlurElement
-instance IsNode SVGFEGaussianBlurElement
-instance IsEventTarget SVGFEGaussianBlurElement
-instance IsGObject SVGFEGaussianBlurElement where
-  toGObject = GObject . unSVGFEGaussianBlurElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SVGFEGaussianBlurElement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSVGFEGaussianBlurElement :: IsGObject obj => obj -> IO SVGFEGaussianBlurElement
-castToSVGFEGaussianBlurElement = castTo gTypeSVGFEGaussianBlurElement "SVGFEGaussianBlurElement"
-
-foreign import javascript unsafe "window[\"SVGFEGaussianBlurElement\"]" gTypeSVGFEGaussianBlurElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SVGFEImageElement".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.SVGElement"
---     * "GHCJS.DOM.Element"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SVGFEImageElement Mozilla SVGFEImageElement documentation>
-newtype SVGFEImageElement = SVGFEImageElement { unSVGFEImageElement :: JSVal }
-
-instance Eq (SVGFEImageElement) where
-  (SVGFEImageElement a) == (SVGFEImageElement b) = js_eq a b
-
-instance PToJSVal SVGFEImageElement where
-  pToJSVal = unSVGFEImageElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SVGFEImageElement where
-  pFromJSVal = SVGFEImageElement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SVGFEImageElement where
-  toJSVal = return . unSVGFEImageElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SVGFEImageElement where
-  fromJSVal = return . fmap SVGFEImageElement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsSVGElement SVGFEImageElement
-instance IsElement SVGFEImageElement
-instance IsNode SVGFEImageElement
-instance IsEventTarget SVGFEImageElement
-instance IsGObject SVGFEImageElement where
-  toGObject = GObject . unSVGFEImageElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SVGFEImageElement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSVGFEImageElement :: IsGObject obj => obj -> IO SVGFEImageElement
-castToSVGFEImageElement = castTo gTypeSVGFEImageElement "SVGFEImageElement"
-
-foreign import javascript unsafe "window[\"SVGFEImageElement\"]" gTypeSVGFEImageElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SVGFEMergeElement".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.SVGElement"
---     * "GHCJS.DOM.Element"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SVGFEMergeElement Mozilla SVGFEMergeElement documentation>
-newtype SVGFEMergeElement = SVGFEMergeElement { unSVGFEMergeElement :: JSVal }
-
-instance Eq (SVGFEMergeElement) where
-  (SVGFEMergeElement a) == (SVGFEMergeElement b) = js_eq a b
-
-instance PToJSVal SVGFEMergeElement where
-  pToJSVal = unSVGFEMergeElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SVGFEMergeElement where
-  pFromJSVal = SVGFEMergeElement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SVGFEMergeElement where
-  toJSVal = return . unSVGFEMergeElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SVGFEMergeElement where
-  fromJSVal = return . fmap SVGFEMergeElement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsSVGElement SVGFEMergeElement
-instance IsElement SVGFEMergeElement
-instance IsNode SVGFEMergeElement
-instance IsEventTarget SVGFEMergeElement
-instance IsGObject SVGFEMergeElement where
-  toGObject = GObject . unSVGFEMergeElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SVGFEMergeElement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSVGFEMergeElement :: IsGObject obj => obj -> IO SVGFEMergeElement
-castToSVGFEMergeElement = castTo gTypeSVGFEMergeElement "SVGFEMergeElement"
-
-foreign import javascript unsafe "window[\"SVGFEMergeElement\"]" gTypeSVGFEMergeElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SVGFEMergeNodeElement".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.SVGElement"
---     * "GHCJS.DOM.Element"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SVGFEMergeNodeElement Mozilla SVGFEMergeNodeElement documentation>
-newtype SVGFEMergeNodeElement = SVGFEMergeNodeElement { unSVGFEMergeNodeElement :: JSVal }
-
-instance Eq (SVGFEMergeNodeElement) where
-  (SVGFEMergeNodeElement a) == (SVGFEMergeNodeElement b) = js_eq a b
-
-instance PToJSVal SVGFEMergeNodeElement where
-  pToJSVal = unSVGFEMergeNodeElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SVGFEMergeNodeElement where
-  pFromJSVal = SVGFEMergeNodeElement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SVGFEMergeNodeElement where
-  toJSVal = return . unSVGFEMergeNodeElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SVGFEMergeNodeElement where
-  fromJSVal = return . fmap SVGFEMergeNodeElement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsSVGElement SVGFEMergeNodeElement
-instance IsElement SVGFEMergeNodeElement
-instance IsNode SVGFEMergeNodeElement
-instance IsEventTarget SVGFEMergeNodeElement
-instance IsGObject SVGFEMergeNodeElement where
-  toGObject = GObject . unSVGFEMergeNodeElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SVGFEMergeNodeElement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSVGFEMergeNodeElement :: IsGObject obj => obj -> IO SVGFEMergeNodeElement
-castToSVGFEMergeNodeElement = castTo gTypeSVGFEMergeNodeElement "SVGFEMergeNodeElement"
-
-foreign import javascript unsafe "window[\"SVGFEMergeNodeElement\"]" gTypeSVGFEMergeNodeElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SVGFEMorphologyElement".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.SVGElement"
---     * "GHCJS.DOM.Element"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SVGFEMorphologyElement Mozilla SVGFEMorphologyElement documentation>
-newtype SVGFEMorphologyElement = SVGFEMorphologyElement { unSVGFEMorphologyElement :: JSVal }
-
-instance Eq (SVGFEMorphologyElement) where
-  (SVGFEMorphologyElement a) == (SVGFEMorphologyElement b) = js_eq a b
-
-instance PToJSVal SVGFEMorphologyElement where
-  pToJSVal = unSVGFEMorphologyElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SVGFEMorphologyElement where
-  pFromJSVal = SVGFEMorphologyElement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SVGFEMorphologyElement where
-  toJSVal = return . unSVGFEMorphologyElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SVGFEMorphologyElement where
-  fromJSVal = return . fmap SVGFEMorphologyElement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsSVGElement SVGFEMorphologyElement
-instance IsElement SVGFEMorphologyElement
-instance IsNode SVGFEMorphologyElement
-instance IsEventTarget SVGFEMorphologyElement
-instance IsGObject SVGFEMorphologyElement where
-  toGObject = GObject . unSVGFEMorphologyElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SVGFEMorphologyElement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSVGFEMorphologyElement :: IsGObject obj => obj -> IO SVGFEMorphologyElement
-castToSVGFEMorphologyElement = castTo gTypeSVGFEMorphologyElement "SVGFEMorphologyElement"
-
-foreign import javascript unsafe "window[\"SVGFEMorphologyElement\"]" gTypeSVGFEMorphologyElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SVGFEOffsetElement".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.SVGElement"
---     * "GHCJS.DOM.Element"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SVGFEOffsetElement Mozilla SVGFEOffsetElement documentation>
-newtype SVGFEOffsetElement = SVGFEOffsetElement { unSVGFEOffsetElement :: JSVal }
-
-instance Eq (SVGFEOffsetElement) where
-  (SVGFEOffsetElement a) == (SVGFEOffsetElement b) = js_eq a b
-
-instance PToJSVal SVGFEOffsetElement where
-  pToJSVal = unSVGFEOffsetElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SVGFEOffsetElement where
-  pFromJSVal = SVGFEOffsetElement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SVGFEOffsetElement where
-  toJSVal = return . unSVGFEOffsetElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SVGFEOffsetElement where
-  fromJSVal = return . fmap SVGFEOffsetElement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsSVGElement SVGFEOffsetElement
-instance IsElement SVGFEOffsetElement
-instance IsNode SVGFEOffsetElement
-instance IsEventTarget SVGFEOffsetElement
-instance IsGObject SVGFEOffsetElement where
-  toGObject = GObject . unSVGFEOffsetElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SVGFEOffsetElement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSVGFEOffsetElement :: IsGObject obj => obj -> IO SVGFEOffsetElement
-castToSVGFEOffsetElement = castTo gTypeSVGFEOffsetElement "SVGFEOffsetElement"
-
-foreign import javascript unsafe "window[\"SVGFEOffsetElement\"]" gTypeSVGFEOffsetElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SVGFEPointLightElement".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.SVGElement"
---     * "GHCJS.DOM.Element"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SVGFEPointLightElement Mozilla SVGFEPointLightElement documentation>
-newtype SVGFEPointLightElement = SVGFEPointLightElement { unSVGFEPointLightElement :: JSVal }
-
-instance Eq (SVGFEPointLightElement) where
-  (SVGFEPointLightElement a) == (SVGFEPointLightElement b) = js_eq a b
-
-instance PToJSVal SVGFEPointLightElement where
-  pToJSVal = unSVGFEPointLightElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SVGFEPointLightElement where
-  pFromJSVal = SVGFEPointLightElement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SVGFEPointLightElement where
-  toJSVal = return . unSVGFEPointLightElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SVGFEPointLightElement where
-  fromJSVal = return . fmap SVGFEPointLightElement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsSVGElement SVGFEPointLightElement
-instance IsElement SVGFEPointLightElement
-instance IsNode SVGFEPointLightElement
-instance IsEventTarget SVGFEPointLightElement
-instance IsGObject SVGFEPointLightElement where
-  toGObject = GObject . unSVGFEPointLightElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SVGFEPointLightElement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSVGFEPointLightElement :: IsGObject obj => obj -> IO SVGFEPointLightElement
-castToSVGFEPointLightElement = castTo gTypeSVGFEPointLightElement "SVGFEPointLightElement"
-
-foreign import javascript unsafe "window[\"SVGFEPointLightElement\"]" gTypeSVGFEPointLightElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SVGFESpecularLightingElement".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.SVGElement"
---     * "GHCJS.DOM.Element"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SVGFESpecularLightingElement Mozilla SVGFESpecularLightingElement documentation>
-newtype SVGFESpecularLightingElement = SVGFESpecularLightingElement { unSVGFESpecularLightingElement :: JSVal }
-
-instance Eq (SVGFESpecularLightingElement) where
-  (SVGFESpecularLightingElement a) == (SVGFESpecularLightingElement b) = js_eq a b
-
-instance PToJSVal SVGFESpecularLightingElement where
-  pToJSVal = unSVGFESpecularLightingElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SVGFESpecularLightingElement where
-  pFromJSVal = SVGFESpecularLightingElement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SVGFESpecularLightingElement where
-  toJSVal = return . unSVGFESpecularLightingElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SVGFESpecularLightingElement where
-  fromJSVal = return . fmap SVGFESpecularLightingElement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsSVGElement SVGFESpecularLightingElement
-instance IsElement SVGFESpecularLightingElement
-instance IsNode SVGFESpecularLightingElement
-instance IsEventTarget SVGFESpecularLightingElement
-instance IsGObject SVGFESpecularLightingElement where
-  toGObject = GObject . unSVGFESpecularLightingElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SVGFESpecularLightingElement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSVGFESpecularLightingElement :: IsGObject obj => obj -> IO SVGFESpecularLightingElement
-castToSVGFESpecularLightingElement = castTo gTypeSVGFESpecularLightingElement "SVGFESpecularLightingElement"
-
-foreign import javascript unsafe "window[\"SVGFESpecularLightingElement\"]" gTypeSVGFESpecularLightingElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SVGFESpotLightElement".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.SVGElement"
---     * "GHCJS.DOM.Element"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SVGFESpotLightElement Mozilla SVGFESpotLightElement documentation>
-newtype SVGFESpotLightElement = SVGFESpotLightElement { unSVGFESpotLightElement :: JSVal }
-
-instance Eq (SVGFESpotLightElement) where
-  (SVGFESpotLightElement a) == (SVGFESpotLightElement b) = js_eq a b
-
-instance PToJSVal SVGFESpotLightElement where
-  pToJSVal = unSVGFESpotLightElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SVGFESpotLightElement where
-  pFromJSVal = SVGFESpotLightElement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SVGFESpotLightElement where
-  toJSVal = return . unSVGFESpotLightElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SVGFESpotLightElement where
-  fromJSVal = return . fmap SVGFESpotLightElement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsSVGElement SVGFESpotLightElement
-instance IsElement SVGFESpotLightElement
-instance IsNode SVGFESpotLightElement
-instance IsEventTarget SVGFESpotLightElement
-instance IsGObject SVGFESpotLightElement where
-  toGObject = GObject . unSVGFESpotLightElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SVGFESpotLightElement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSVGFESpotLightElement :: IsGObject obj => obj -> IO SVGFESpotLightElement
-castToSVGFESpotLightElement = castTo gTypeSVGFESpotLightElement "SVGFESpotLightElement"
-
-foreign import javascript unsafe "window[\"SVGFESpotLightElement\"]" gTypeSVGFESpotLightElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SVGFETileElement".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.SVGElement"
---     * "GHCJS.DOM.Element"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SVGFETileElement Mozilla SVGFETileElement documentation>
-newtype SVGFETileElement = SVGFETileElement { unSVGFETileElement :: JSVal }
-
-instance Eq (SVGFETileElement) where
-  (SVGFETileElement a) == (SVGFETileElement b) = js_eq a b
-
-instance PToJSVal SVGFETileElement where
-  pToJSVal = unSVGFETileElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SVGFETileElement where
-  pFromJSVal = SVGFETileElement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SVGFETileElement where
-  toJSVal = return . unSVGFETileElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SVGFETileElement where
-  fromJSVal = return . fmap SVGFETileElement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsSVGElement SVGFETileElement
-instance IsElement SVGFETileElement
-instance IsNode SVGFETileElement
-instance IsEventTarget SVGFETileElement
-instance IsGObject SVGFETileElement where
-  toGObject = GObject . unSVGFETileElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SVGFETileElement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSVGFETileElement :: IsGObject obj => obj -> IO SVGFETileElement
-castToSVGFETileElement = castTo gTypeSVGFETileElement "SVGFETileElement"
-
-foreign import javascript unsafe "window[\"SVGFETileElement\"]" gTypeSVGFETileElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SVGFETurbulenceElement".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.SVGElement"
---     * "GHCJS.DOM.Element"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SVGFETurbulenceElement Mozilla SVGFETurbulenceElement documentation>
-newtype SVGFETurbulenceElement = SVGFETurbulenceElement { unSVGFETurbulenceElement :: JSVal }
-
-instance Eq (SVGFETurbulenceElement) where
-  (SVGFETurbulenceElement a) == (SVGFETurbulenceElement b) = js_eq a b
-
-instance PToJSVal SVGFETurbulenceElement where
-  pToJSVal = unSVGFETurbulenceElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SVGFETurbulenceElement where
-  pFromJSVal = SVGFETurbulenceElement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SVGFETurbulenceElement where
-  toJSVal = return . unSVGFETurbulenceElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SVGFETurbulenceElement where
-  fromJSVal = return . fmap SVGFETurbulenceElement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsSVGElement SVGFETurbulenceElement
-instance IsElement SVGFETurbulenceElement
-instance IsNode SVGFETurbulenceElement
-instance IsEventTarget SVGFETurbulenceElement
-instance IsGObject SVGFETurbulenceElement where
-  toGObject = GObject . unSVGFETurbulenceElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SVGFETurbulenceElement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSVGFETurbulenceElement :: IsGObject obj => obj -> IO SVGFETurbulenceElement
-castToSVGFETurbulenceElement = castTo gTypeSVGFETurbulenceElement "SVGFETurbulenceElement"
-
-foreign import javascript unsafe "window[\"SVGFETurbulenceElement\"]" gTypeSVGFETurbulenceElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SVGFilterElement".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.SVGElement"
---     * "GHCJS.DOM.Element"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SVGFilterElement Mozilla SVGFilterElement documentation>
-newtype SVGFilterElement = SVGFilterElement { unSVGFilterElement :: JSVal }
-
-instance Eq (SVGFilterElement) where
-  (SVGFilterElement a) == (SVGFilterElement b) = js_eq a b
-
-instance PToJSVal SVGFilterElement where
-  pToJSVal = unSVGFilterElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SVGFilterElement where
-  pFromJSVal = SVGFilterElement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SVGFilterElement where
-  toJSVal = return . unSVGFilterElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SVGFilterElement where
-  fromJSVal = return . fmap SVGFilterElement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsSVGElement SVGFilterElement
-instance IsElement SVGFilterElement
-instance IsNode SVGFilterElement
-instance IsEventTarget SVGFilterElement
-instance IsGObject SVGFilterElement where
-  toGObject = GObject . unSVGFilterElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SVGFilterElement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSVGFilterElement :: IsGObject obj => obj -> IO SVGFilterElement
-castToSVGFilterElement = castTo gTypeSVGFilterElement "SVGFilterElement"
-
-foreign import javascript unsafe "window[\"SVGFilterElement\"]" gTypeSVGFilterElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SVGFilterPrimitiveStandardAttributes".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SVGFilterPrimitiveStandardAttributes Mozilla SVGFilterPrimitiveStandardAttributes documentation>
-newtype SVGFilterPrimitiveStandardAttributes = SVGFilterPrimitiveStandardAttributes { unSVGFilterPrimitiveStandardAttributes :: JSVal }
-
-instance Eq (SVGFilterPrimitiveStandardAttributes) where
-  (SVGFilterPrimitiveStandardAttributes a) == (SVGFilterPrimitiveStandardAttributes b) = js_eq a b
-
-instance PToJSVal SVGFilterPrimitiveStandardAttributes where
-  pToJSVal = unSVGFilterPrimitiveStandardAttributes
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SVGFilterPrimitiveStandardAttributes where
-  pFromJSVal = SVGFilterPrimitiveStandardAttributes
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SVGFilterPrimitiveStandardAttributes where
-  toJSVal = return . unSVGFilterPrimitiveStandardAttributes
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SVGFilterPrimitiveStandardAttributes where
-  fromJSVal = return . fmap SVGFilterPrimitiveStandardAttributes . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject SVGFilterPrimitiveStandardAttributes where
-  toGObject = GObject . unSVGFilterPrimitiveStandardAttributes
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SVGFilterPrimitiveStandardAttributes . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSVGFilterPrimitiveStandardAttributes :: IsGObject obj => obj -> IO SVGFilterPrimitiveStandardAttributes
-castToSVGFilterPrimitiveStandardAttributes = castTo gTypeSVGFilterPrimitiveStandardAttributes "SVGFilterPrimitiveStandardAttributes"
-
-foreign import javascript unsafe "window[\"SVGFilterPrimitiveStandardAttributes\"]" gTypeSVGFilterPrimitiveStandardAttributes :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SVGFitToViewBox".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SVGFitToViewBox Mozilla SVGFitToViewBox documentation>
-newtype SVGFitToViewBox = SVGFitToViewBox { unSVGFitToViewBox :: JSVal }
-
-instance Eq (SVGFitToViewBox) where
-  (SVGFitToViewBox a) == (SVGFitToViewBox b) = js_eq a b
-
-instance PToJSVal SVGFitToViewBox where
-  pToJSVal = unSVGFitToViewBox
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SVGFitToViewBox where
-  pFromJSVal = SVGFitToViewBox
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SVGFitToViewBox where
-  toJSVal = return . unSVGFitToViewBox
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SVGFitToViewBox where
-  fromJSVal = return . fmap SVGFitToViewBox . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject SVGFitToViewBox where
-  toGObject = GObject . unSVGFitToViewBox
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SVGFitToViewBox . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSVGFitToViewBox :: IsGObject obj => obj -> IO SVGFitToViewBox
-castToSVGFitToViewBox = castTo gTypeSVGFitToViewBox "SVGFitToViewBox"
-
-foreign import javascript unsafe "window[\"SVGFitToViewBox\"]" gTypeSVGFitToViewBox :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SVGFontElement".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.SVGElement"
---     * "GHCJS.DOM.Element"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SVGFontElement Mozilla SVGFontElement documentation>
-newtype SVGFontElement = SVGFontElement { unSVGFontElement :: JSVal }
-
-instance Eq (SVGFontElement) where
-  (SVGFontElement a) == (SVGFontElement b) = js_eq a b
-
-instance PToJSVal SVGFontElement where
-  pToJSVal = unSVGFontElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SVGFontElement where
-  pFromJSVal = SVGFontElement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SVGFontElement where
-  toJSVal = return . unSVGFontElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SVGFontElement where
-  fromJSVal = return . fmap SVGFontElement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsSVGElement SVGFontElement
-instance IsElement SVGFontElement
-instance IsNode SVGFontElement
-instance IsEventTarget SVGFontElement
-instance IsGObject SVGFontElement where
-  toGObject = GObject . unSVGFontElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SVGFontElement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSVGFontElement :: IsGObject obj => obj -> IO SVGFontElement
-castToSVGFontElement = castTo gTypeSVGFontElement "SVGFontElement"
-
-foreign import javascript unsafe "window[\"SVGFontElement\"]" gTypeSVGFontElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SVGFontFaceElement".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.SVGElement"
---     * "GHCJS.DOM.Element"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SVGFontFaceElement Mozilla SVGFontFaceElement documentation>
-newtype SVGFontFaceElement = SVGFontFaceElement { unSVGFontFaceElement :: JSVal }
-
-instance Eq (SVGFontFaceElement) where
-  (SVGFontFaceElement a) == (SVGFontFaceElement b) = js_eq a b
-
-instance PToJSVal SVGFontFaceElement where
-  pToJSVal = unSVGFontFaceElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SVGFontFaceElement where
-  pFromJSVal = SVGFontFaceElement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SVGFontFaceElement where
-  toJSVal = return . unSVGFontFaceElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SVGFontFaceElement where
-  fromJSVal = return . fmap SVGFontFaceElement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsSVGElement SVGFontFaceElement
-instance IsElement SVGFontFaceElement
-instance IsNode SVGFontFaceElement
-instance IsEventTarget SVGFontFaceElement
-instance IsGObject SVGFontFaceElement where
-  toGObject = GObject . unSVGFontFaceElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SVGFontFaceElement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSVGFontFaceElement :: IsGObject obj => obj -> IO SVGFontFaceElement
-castToSVGFontFaceElement = castTo gTypeSVGFontFaceElement "SVGFontFaceElement"
-
-foreign import javascript unsafe "window[\"SVGFontFaceElement\"]" gTypeSVGFontFaceElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SVGFontFaceFormatElement".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.SVGElement"
---     * "GHCJS.DOM.Element"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SVGFontFaceFormatElement Mozilla SVGFontFaceFormatElement documentation>
-newtype SVGFontFaceFormatElement = SVGFontFaceFormatElement { unSVGFontFaceFormatElement :: JSVal }
-
-instance Eq (SVGFontFaceFormatElement) where
-  (SVGFontFaceFormatElement a) == (SVGFontFaceFormatElement b) = js_eq a b
-
-instance PToJSVal SVGFontFaceFormatElement where
-  pToJSVal = unSVGFontFaceFormatElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SVGFontFaceFormatElement where
-  pFromJSVal = SVGFontFaceFormatElement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SVGFontFaceFormatElement where
-  toJSVal = return . unSVGFontFaceFormatElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SVGFontFaceFormatElement where
-  fromJSVal = return . fmap SVGFontFaceFormatElement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsSVGElement SVGFontFaceFormatElement
-instance IsElement SVGFontFaceFormatElement
-instance IsNode SVGFontFaceFormatElement
-instance IsEventTarget SVGFontFaceFormatElement
-instance IsGObject SVGFontFaceFormatElement where
-  toGObject = GObject . unSVGFontFaceFormatElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SVGFontFaceFormatElement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSVGFontFaceFormatElement :: IsGObject obj => obj -> IO SVGFontFaceFormatElement
-castToSVGFontFaceFormatElement = castTo gTypeSVGFontFaceFormatElement "SVGFontFaceFormatElement"
-
-foreign import javascript unsafe "window[\"SVGFontFaceFormatElement\"]" gTypeSVGFontFaceFormatElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SVGFontFaceNameElement".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.SVGElement"
---     * "GHCJS.DOM.Element"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SVGFontFaceNameElement Mozilla SVGFontFaceNameElement documentation>
-newtype SVGFontFaceNameElement = SVGFontFaceNameElement { unSVGFontFaceNameElement :: JSVal }
-
-instance Eq (SVGFontFaceNameElement) where
-  (SVGFontFaceNameElement a) == (SVGFontFaceNameElement b) = js_eq a b
-
-instance PToJSVal SVGFontFaceNameElement where
-  pToJSVal = unSVGFontFaceNameElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SVGFontFaceNameElement where
-  pFromJSVal = SVGFontFaceNameElement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SVGFontFaceNameElement where
-  toJSVal = return . unSVGFontFaceNameElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SVGFontFaceNameElement where
-  fromJSVal = return . fmap SVGFontFaceNameElement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsSVGElement SVGFontFaceNameElement
-instance IsElement SVGFontFaceNameElement
-instance IsNode SVGFontFaceNameElement
-instance IsEventTarget SVGFontFaceNameElement
-instance IsGObject SVGFontFaceNameElement where
-  toGObject = GObject . unSVGFontFaceNameElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SVGFontFaceNameElement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSVGFontFaceNameElement :: IsGObject obj => obj -> IO SVGFontFaceNameElement
-castToSVGFontFaceNameElement = castTo gTypeSVGFontFaceNameElement "SVGFontFaceNameElement"
-
-foreign import javascript unsafe "window[\"SVGFontFaceNameElement\"]" gTypeSVGFontFaceNameElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SVGFontFaceSrcElement".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.SVGElement"
---     * "GHCJS.DOM.Element"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SVGFontFaceSrcElement Mozilla SVGFontFaceSrcElement documentation>
-newtype SVGFontFaceSrcElement = SVGFontFaceSrcElement { unSVGFontFaceSrcElement :: JSVal }
-
-instance Eq (SVGFontFaceSrcElement) where
-  (SVGFontFaceSrcElement a) == (SVGFontFaceSrcElement b) = js_eq a b
-
-instance PToJSVal SVGFontFaceSrcElement where
-  pToJSVal = unSVGFontFaceSrcElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SVGFontFaceSrcElement where
-  pFromJSVal = SVGFontFaceSrcElement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SVGFontFaceSrcElement where
-  toJSVal = return . unSVGFontFaceSrcElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SVGFontFaceSrcElement where
-  fromJSVal = return . fmap SVGFontFaceSrcElement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsSVGElement SVGFontFaceSrcElement
-instance IsElement SVGFontFaceSrcElement
-instance IsNode SVGFontFaceSrcElement
-instance IsEventTarget SVGFontFaceSrcElement
-instance IsGObject SVGFontFaceSrcElement where
-  toGObject = GObject . unSVGFontFaceSrcElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SVGFontFaceSrcElement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSVGFontFaceSrcElement :: IsGObject obj => obj -> IO SVGFontFaceSrcElement
-castToSVGFontFaceSrcElement = castTo gTypeSVGFontFaceSrcElement "SVGFontFaceSrcElement"
-
-foreign import javascript unsafe "window[\"SVGFontFaceSrcElement\"]" gTypeSVGFontFaceSrcElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SVGFontFaceUriElement".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.SVGElement"
---     * "GHCJS.DOM.Element"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SVGFontFaceUriElement Mozilla SVGFontFaceUriElement documentation>
-newtype SVGFontFaceUriElement = SVGFontFaceUriElement { unSVGFontFaceUriElement :: JSVal }
-
-instance Eq (SVGFontFaceUriElement) where
-  (SVGFontFaceUriElement a) == (SVGFontFaceUriElement b) = js_eq a b
-
-instance PToJSVal SVGFontFaceUriElement where
-  pToJSVal = unSVGFontFaceUriElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SVGFontFaceUriElement where
-  pFromJSVal = SVGFontFaceUriElement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SVGFontFaceUriElement where
-  toJSVal = return . unSVGFontFaceUriElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SVGFontFaceUriElement where
-  fromJSVal = return . fmap SVGFontFaceUriElement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsSVGElement SVGFontFaceUriElement
-instance IsElement SVGFontFaceUriElement
-instance IsNode SVGFontFaceUriElement
-instance IsEventTarget SVGFontFaceUriElement
-instance IsGObject SVGFontFaceUriElement where
-  toGObject = GObject . unSVGFontFaceUriElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SVGFontFaceUriElement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSVGFontFaceUriElement :: IsGObject obj => obj -> IO SVGFontFaceUriElement
-castToSVGFontFaceUriElement = castTo gTypeSVGFontFaceUriElement "SVGFontFaceUriElement"
-
-foreign import javascript unsafe "window[\"SVGFontFaceUriElement\"]" gTypeSVGFontFaceUriElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SVGForeignObjectElement".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.SVGGraphicsElement"
---     * "GHCJS.DOM.SVGElement"
---     * "GHCJS.DOM.Element"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SVGForeignObjectElement Mozilla SVGForeignObjectElement documentation>
-newtype SVGForeignObjectElement = SVGForeignObjectElement { unSVGForeignObjectElement :: JSVal }
-
-instance Eq (SVGForeignObjectElement) where
-  (SVGForeignObjectElement a) == (SVGForeignObjectElement b) = js_eq a b
-
-instance PToJSVal SVGForeignObjectElement where
-  pToJSVal = unSVGForeignObjectElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SVGForeignObjectElement where
-  pFromJSVal = SVGForeignObjectElement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SVGForeignObjectElement where
-  toJSVal = return . unSVGForeignObjectElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SVGForeignObjectElement where
-  fromJSVal = return . fmap SVGForeignObjectElement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsSVGGraphicsElement SVGForeignObjectElement
-instance IsSVGElement SVGForeignObjectElement
-instance IsElement SVGForeignObjectElement
-instance IsNode SVGForeignObjectElement
-instance IsEventTarget SVGForeignObjectElement
-instance IsGObject SVGForeignObjectElement where
-  toGObject = GObject . unSVGForeignObjectElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SVGForeignObjectElement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSVGForeignObjectElement :: IsGObject obj => obj -> IO SVGForeignObjectElement
-castToSVGForeignObjectElement = castTo gTypeSVGForeignObjectElement "SVGForeignObjectElement"
-
-foreign import javascript unsafe "window[\"SVGForeignObjectElement\"]" gTypeSVGForeignObjectElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SVGGElement".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.SVGGraphicsElement"
---     * "GHCJS.DOM.SVGElement"
---     * "GHCJS.DOM.Element"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SVGGElement Mozilla SVGGElement documentation>
-newtype SVGGElement = SVGGElement { unSVGGElement :: JSVal }
-
-instance Eq (SVGGElement) where
-  (SVGGElement a) == (SVGGElement b) = js_eq a b
-
-instance PToJSVal SVGGElement where
-  pToJSVal = unSVGGElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SVGGElement where
-  pFromJSVal = SVGGElement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SVGGElement where
-  toJSVal = return . unSVGGElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SVGGElement where
-  fromJSVal = return . fmap SVGGElement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsSVGGraphicsElement SVGGElement
-instance IsSVGElement SVGGElement
-instance IsElement SVGGElement
-instance IsNode SVGGElement
-instance IsEventTarget SVGGElement
-instance IsGObject SVGGElement where
-  toGObject = GObject . unSVGGElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SVGGElement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSVGGElement :: IsGObject obj => obj -> IO SVGGElement
-castToSVGGElement = castTo gTypeSVGGElement "SVGGElement"
-
-foreign import javascript unsafe "window[\"SVGGElement\"]" gTypeSVGGElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SVGGlyphElement".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.SVGElement"
---     * "GHCJS.DOM.Element"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SVGGlyphElement Mozilla SVGGlyphElement documentation>
-newtype SVGGlyphElement = SVGGlyphElement { unSVGGlyphElement :: JSVal }
-
-instance Eq (SVGGlyphElement) where
-  (SVGGlyphElement a) == (SVGGlyphElement b) = js_eq a b
-
-instance PToJSVal SVGGlyphElement where
-  pToJSVal = unSVGGlyphElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SVGGlyphElement where
-  pFromJSVal = SVGGlyphElement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SVGGlyphElement where
-  toJSVal = return . unSVGGlyphElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SVGGlyphElement where
-  fromJSVal = return . fmap SVGGlyphElement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsSVGElement SVGGlyphElement
-instance IsElement SVGGlyphElement
-instance IsNode SVGGlyphElement
-instance IsEventTarget SVGGlyphElement
-instance IsGObject SVGGlyphElement where
-  toGObject = GObject . unSVGGlyphElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SVGGlyphElement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSVGGlyphElement :: IsGObject obj => obj -> IO SVGGlyphElement
-castToSVGGlyphElement = castTo gTypeSVGGlyphElement "SVGGlyphElement"
-
-foreign import javascript unsafe "window[\"SVGGlyphElement\"]" gTypeSVGGlyphElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SVGGlyphRefElement".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.SVGElement"
---     * "GHCJS.DOM.Element"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SVGGlyphRefElement Mozilla SVGGlyphRefElement documentation>
-newtype SVGGlyphRefElement = SVGGlyphRefElement { unSVGGlyphRefElement :: JSVal }
-
-instance Eq (SVGGlyphRefElement) where
-  (SVGGlyphRefElement a) == (SVGGlyphRefElement b) = js_eq a b
-
-instance PToJSVal SVGGlyphRefElement where
-  pToJSVal = unSVGGlyphRefElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SVGGlyphRefElement where
-  pFromJSVal = SVGGlyphRefElement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SVGGlyphRefElement where
-  toJSVal = return . unSVGGlyphRefElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SVGGlyphRefElement where
-  fromJSVal = return . fmap SVGGlyphRefElement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsSVGElement SVGGlyphRefElement
-instance IsElement SVGGlyphRefElement
-instance IsNode SVGGlyphRefElement
-instance IsEventTarget SVGGlyphRefElement
-instance IsGObject SVGGlyphRefElement where
-  toGObject = GObject . unSVGGlyphRefElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SVGGlyphRefElement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSVGGlyphRefElement :: IsGObject obj => obj -> IO SVGGlyphRefElement
-castToSVGGlyphRefElement = castTo gTypeSVGGlyphRefElement "SVGGlyphRefElement"
-
-foreign import javascript unsafe "window[\"SVGGlyphRefElement\"]" gTypeSVGGlyphRefElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SVGGradientElement".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.SVGElement"
---     * "GHCJS.DOM.Element"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SVGGradientElement Mozilla SVGGradientElement documentation>
-newtype SVGGradientElement = SVGGradientElement { unSVGGradientElement :: JSVal }
-
-instance Eq (SVGGradientElement) where
-  (SVGGradientElement a) == (SVGGradientElement b) = js_eq a b
-
-instance PToJSVal SVGGradientElement where
-  pToJSVal = unSVGGradientElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SVGGradientElement where
-  pFromJSVal = SVGGradientElement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SVGGradientElement where
-  toJSVal = return . unSVGGradientElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SVGGradientElement where
-  fromJSVal = return . fmap SVGGradientElement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-class IsSVGElement o => IsSVGGradientElement o
-toSVGGradientElement :: IsSVGGradientElement o => o -> SVGGradientElement
-toSVGGradientElement = unsafeCastGObject . toGObject
-
-instance IsSVGGradientElement SVGGradientElement
-instance IsSVGElement SVGGradientElement
-instance IsElement SVGGradientElement
-instance IsNode SVGGradientElement
-instance IsEventTarget SVGGradientElement
-instance IsGObject SVGGradientElement where
-  toGObject = GObject . unSVGGradientElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SVGGradientElement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSVGGradientElement :: IsGObject obj => obj -> IO SVGGradientElement
-castToSVGGradientElement = castTo gTypeSVGGradientElement "SVGGradientElement"
-
-foreign import javascript unsafe "window[\"SVGGradientElement\"]" gTypeSVGGradientElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SVGGraphicsElement".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.SVGElement"
---     * "GHCJS.DOM.Element"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SVGGraphicsElement Mozilla SVGGraphicsElement documentation>
-newtype SVGGraphicsElement = SVGGraphicsElement { unSVGGraphicsElement :: JSVal }
-
-instance Eq (SVGGraphicsElement) where
-  (SVGGraphicsElement a) == (SVGGraphicsElement b) = js_eq a b
-
-instance PToJSVal SVGGraphicsElement where
-  pToJSVal = unSVGGraphicsElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SVGGraphicsElement where
-  pFromJSVal = SVGGraphicsElement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SVGGraphicsElement where
-  toJSVal = return . unSVGGraphicsElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SVGGraphicsElement where
-  fromJSVal = return . fmap SVGGraphicsElement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-class IsSVGElement o => IsSVGGraphicsElement o
-toSVGGraphicsElement :: IsSVGGraphicsElement o => o -> SVGGraphicsElement
-toSVGGraphicsElement = unsafeCastGObject . toGObject
-
-instance IsSVGGraphicsElement SVGGraphicsElement
-instance IsSVGElement SVGGraphicsElement
-instance IsElement SVGGraphicsElement
-instance IsNode SVGGraphicsElement
-instance IsEventTarget SVGGraphicsElement
-instance IsGObject SVGGraphicsElement where
-  toGObject = GObject . unSVGGraphicsElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SVGGraphicsElement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSVGGraphicsElement :: IsGObject obj => obj -> IO SVGGraphicsElement
-castToSVGGraphicsElement = castTo gTypeSVGGraphicsElement "SVGGraphicsElement"
-
-foreign import javascript unsafe "window[\"SVGGraphicsElement\"]" gTypeSVGGraphicsElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SVGHKernElement".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.SVGElement"
---     * "GHCJS.DOM.Element"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SVGHKernElement Mozilla SVGHKernElement documentation>
-newtype SVGHKernElement = SVGHKernElement { unSVGHKernElement :: JSVal }
-
-instance Eq (SVGHKernElement) where
-  (SVGHKernElement a) == (SVGHKernElement b) = js_eq a b
-
-instance PToJSVal SVGHKernElement where
-  pToJSVal = unSVGHKernElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SVGHKernElement where
-  pFromJSVal = SVGHKernElement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SVGHKernElement where
-  toJSVal = return . unSVGHKernElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SVGHKernElement where
-  fromJSVal = return . fmap SVGHKernElement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsSVGElement SVGHKernElement
-instance IsElement SVGHKernElement
-instance IsNode SVGHKernElement
-instance IsEventTarget SVGHKernElement
-instance IsGObject SVGHKernElement where
-  toGObject = GObject . unSVGHKernElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SVGHKernElement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSVGHKernElement :: IsGObject obj => obj -> IO SVGHKernElement
-castToSVGHKernElement = castTo gTypeSVGHKernElement "SVGHKernElement"
-
-foreign import javascript unsafe "window[\"SVGHKernElement\"]" gTypeSVGHKernElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SVGImageElement".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.SVGGraphicsElement"
---     * "GHCJS.DOM.SVGElement"
---     * "GHCJS.DOM.Element"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SVGImageElement Mozilla SVGImageElement documentation>
-newtype SVGImageElement = SVGImageElement { unSVGImageElement :: JSVal }
-
-instance Eq (SVGImageElement) where
-  (SVGImageElement a) == (SVGImageElement b) = js_eq a b
-
-instance PToJSVal SVGImageElement where
-  pToJSVal = unSVGImageElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SVGImageElement where
-  pFromJSVal = SVGImageElement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SVGImageElement where
-  toJSVal = return . unSVGImageElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SVGImageElement where
-  fromJSVal = return . fmap SVGImageElement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsSVGGraphicsElement SVGImageElement
-instance IsSVGElement SVGImageElement
-instance IsElement SVGImageElement
-instance IsNode SVGImageElement
-instance IsEventTarget SVGImageElement
-instance IsGObject SVGImageElement where
-  toGObject = GObject . unSVGImageElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SVGImageElement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSVGImageElement :: IsGObject obj => obj -> IO SVGImageElement
-castToSVGImageElement = castTo gTypeSVGImageElement "SVGImageElement"
-
-foreign import javascript unsafe "window[\"SVGImageElement\"]" gTypeSVGImageElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SVGLength".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SVGLength Mozilla SVGLength documentation>
-newtype SVGLength = SVGLength { unSVGLength :: JSVal }
-
-instance Eq (SVGLength) where
-  (SVGLength a) == (SVGLength b) = js_eq a b
-
-instance PToJSVal SVGLength where
-  pToJSVal = unSVGLength
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SVGLength where
-  pFromJSVal = SVGLength
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SVGLength where
-  toJSVal = return . unSVGLength
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SVGLength where
-  fromJSVal = return . fmap SVGLength . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject SVGLength where
-  toGObject = GObject . unSVGLength
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SVGLength . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSVGLength :: IsGObject obj => obj -> IO SVGLength
-castToSVGLength = castTo gTypeSVGLength "SVGLength"
-
-foreign import javascript unsafe "window[\"SVGLength\"]" gTypeSVGLength :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SVGLengthList".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SVGLengthList Mozilla SVGLengthList documentation>
-newtype SVGLengthList = SVGLengthList { unSVGLengthList :: JSVal }
-
-instance Eq (SVGLengthList) where
-  (SVGLengthList a) == (SVGLengthList b) = js_eq a b
-
-instance PToJSVal SVGLengthList where
-  pToJSVal = unSVGLengthList
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SVGLengthList where
-  pFromJSVal = SVGLengthList
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SVGLengthList where
-  toJSVal = return . unSVGLengthList
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SVGLengthList where
-  fromJSVal = return . fmap SVGLengthList . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject SVGLengthList where
-  toGObject = GObject . unSVGLengthList
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SVGLengthList . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSVGLengthList :: IsGObject obj => obj -> IO SVGLengthList
-castToSVGLengthList = castTo gTypeSVGLengthList "SVGLengthList"
-
-foreign import javascript unsafe "window[\"SVGLengthList\"]" gTypeSVGLengthList :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SVGLineElement".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.SVGGraphicsElement"
---     * "GHCJS.DOM.SVGElement"
---     * "GHCJS.DOM.Element"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SVGLineElement Mozilla SVGLineElement documentation>
-newtype SVGLineElement = SVGLineElement { unSVGLineElement :: JSVal }
-
-instance Eq (SVGLineElement) where
-  (SVGLineElement a) == (SVGLineElement b) = js_eq a b
-
-instance PToJSVal SVGLineElement where
-  pToJSVal = unSVGLineElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SVGLineElement where
-  pFromJSVal = SVGLineElement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SVGLineElement where
-  toJSVal = return . unSVGLineElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SVGLineElement where
-  fromJSVal = return . fmap SVGLineElement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsSVGGraphicsElement SVGLineElement
-instance IsSVGElement SVGLineElement
-instance IsElement SVGLineElement
-instance IsNode SVGLineElement
-instance IsEventTarget SVGLineElement
-instance IsGObject SVGLineElement where
-  toGObject = GObject . unSVGLineElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SVGLineElement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSVGLineElement :: IsGObject obj => obj -> IO SVGLineElement
-castToSVGLineElement = castTo gTypeSVGLineElement "SVGLineElement"
-
-foreign import javascript unsafe "window[\"SVGLineElement\"]" gTypeSVGLineElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SVGLinearGradientElement".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.SVGGradientElement"
---     * "GHCJS.DOM.SVGElement"
---     * "GHCJS.DOM.Element"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SVGLinearGradientElement Mozilla SVGLinearGradientElement documentation>
-newtype SVGLinearGradientElement = SVGLinearGradientElement { unSVGLinearGradientElement :: JSVal }
-
-instance Eq (SVGLinearGradientElement) where
-  (SVGLinearGradientElement a) == (SVGLinearGradientElement b) = js_eq a b
-
-instance PToJSVal SVGLinearGradientElement where
-  pToJSVal = unSVGLinearGradientElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SVGLinearGradientElement where
-  pFromJSVal = SVGLinearGradientElement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SVGLinearGradientElement where
-  toJSVal = return . unSVGLinearGradientElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SVGLinearGradientElement where
-  fromJSVal = return . fmap SVGLinearGradientElement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsSVGGradientElement SVGLinearGradientElement
-instance IsSVGElement SVGLinearGradientElement
-instance IsElement SVGLinearGradientElement
-instance IsNode SVGLinearGradientElement
-instance IsEventTarget SVGLinearGradientElement
-instance IsGObject SVGLinearGradientElement where
-  toGObject = GObject . unSVGLinearGradientElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SVGLinearGradientElement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSVGLinearGradientElement :: IsGObject obj => obj -> IO SVGLinearGradientElement
-castToSVGLinearGradientElement = castTo gTypeSVGLinearGradientElement "SVGLinearGradientElement"
-
-foreign import javascript unsafe "window[\"SVGLinearGradientElement\"]" gTypeSVGLinearGradientElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SVGMPathElement".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.SVGElement"
---     * "GHCJS.DOM.Element"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SVGMPathElement Mozilla SVGMPathElement documentation>
-newtype SVGMPathElement = SVGMPathElement { unSVGMPathElement :: JSVal }
-
-instance Eq (SVGMPathElement) where
-  (SVGMPathElement a) == (SVGMPathElement b) = js_eq a b
-
-instance PToJSVal SVGMPathElement where
-  pToJSVal = unSVGMPathElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SVGMPathElement where
-  pFromJSVal = SVGMPathElement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SVGMPathElement where
-  toJSVal = return . unSVGMPathElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SVGMPathElement where
-  fromJSVal = return . fmap SVGMPathElement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsSVGElement SVGMPathElement
-instance IsElement SVGMPathElement
-instance IsNode SVGMPathElement
-instance IsEventTarget SVGMPathElement
-instance IsGObject SVGMPathElement where
-  toGObject = GObject . unSVGMPathElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SVGMPathElement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSVGMPathElement :: IsGObject obj => obj -> IO SVGMPathElement
-castToSVGMPathElement = castTo gTypeSVGMPathElement "SVGMPathElement"
-
-foreign import javascript unsafe "window[\"SVGMPathElement\"]" gTypeSVGMPathElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SVGMarkerElement".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.SVGElement"
---     * "GHCJS.DOM.Element"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SVGMarkerElement Mozilla SVGMarkerElement documentation>
-newtype SVGMarkerElement = SVGMarkerElement { unSVGMarkerElement :: JSVal }
-
-instance Eq (SVGMarkerElement) where
-  (SVGMarkerElement a) == (SVGMarkerElement b) = js_eq a b
-
-instance PToJSVal SVGMarkerElement where
-  pToJSVal = unSVGMarkerElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SVGMarkerElement where
-  pFromJSVal = SVGMarkerElement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SVGMarkerElement where
-  toJSVal = return . unSVGMarkerElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SVGMarkerElement where
-  fromJSVal = return . fmap SVGMarkerElement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsSVGElement SVGMarkerElement
-instance IsElement SVGMarkerElement
-instance IsNode SVGMarkerElement
-instance IsEventTarget SVGMarkerElement
-instance IsGObject SVGMarkerElement where
-  toGObject = GObject . unSVGMarkerElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SVGMarkerElement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSVGMarkerElement :: IsGObject obj => obj -> IO SVGMarkerElement
-castToSVGMarkerElement = castTo gTypeSVGMarkerElement "SVGMarkerElement"
-
-foreign import javascript unsafe "window[\"SVGMarkerElement\"]" gTypeSVGMarkerElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SVGMaskElement".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.SVGElement"
---     * "GHCJS.DOM.Element"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SVGMaskElement Mozilla SVGMaskElement documentation>
-newtype SVGMaskElement = SVGMaskElement { unSVGMaskElement :: JSVal }
-
-instance Eq (SVGMaskElement) where
-  (SVGMaskElement a) == (SVGMaskElement b) = js_eq a b
-
-instance PToJSVal SVGMaskElement where
-  pToJSVal = unSVGMaskElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SVGMaskElement where
-  pFromJSVal = SVGMaskElement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SVGMaskElement where
-  toJSVal = return . unSVGMaskElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SVGMaskElement where
-  fromJSVal = return . fmap SVGMaskElement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsSVGElement SVGMaskElement
-instance IsElement SVGMaskElement
-instance IsNode SVGMaskElement
-instance IsEventTarget SVGMaskElement
-instance IsGObject SVGMaskElement where
-  toGObject = GObject . unSVGMaskElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SVGMaskElement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSVGMaskElement :: IsGObject obj => obj -> IO SVGMaskElement
-castToSVGMaskElement = castTo gTypeSVGMaskElement "SVGMaskElement"
-
-foreign import javascript unsafe "window[\"SVGMaskElement\"]" gTypeSVGMaskElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SVGMatrix".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SVGMatrix Mozilla SVGMatrix documentation>
-newtype SVGMatrix = SVGMatrix { unSVGMatrix :: JSVal }
-
-instance Eq (SVGMatrix) where
-  (SVGMatrix a) == (SVGMatrix b) = js_eq a b
-
-instance PToJSVal SVGMatrix where
-  pToJSVal = unSVGMatrix
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SVGMatrix where
-  pFromJSVal = SVGMatrix
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SVGMatrix where
-  toJSVal = return . unSVGMatrix
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SVGMatrix where
-  fromJSVal = return . fmap SVGMatrix . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject SVGMatrix where
-  toGObject = GObject . unSVGMatrix
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SVGMatrix . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSVGMatrix :: IsGObject obj => obj -> IO SVGMatrix
-castToSVGMatrix = castTo gTypeSVGMatrix "SVGMatrix"
-
-foreign import javascript unsafe "window[\"SVGMatrix\"]" gTypeSVGMatrix :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SVGMetadataElement".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.SVGElement"
---     * "GHCJS.DOM.Element"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SVGMetadataElement Mozilla SVGMetadataElement documentation>
-newtype SVGMetadataElement = SVGMetadataElement { unSVGMetadataElement :: JSVal }
-
-instance Eq (SVGMetadataElement) where
-  (SVGMetadataElement a) == (SVGMetadataElement b) = js_eq a b
-
-instance PToJSVal SVGMetadataElement where
-  pToJSVal = unSVGMetadataElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SVGMetadataElement where
-  pFromJSVal = SVGMetadataElement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SVGMetadataElement where
-  toJSVal = return . unSVGMetadataElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SVGMetadataElement where
-  fromJSVal = return . fmap SVGMetadataElement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsSVGElement SVGMetadataElement
-instance IsElement SVGMetadataElement
-instance IsNode SVGMetadataElement
-instance IsEventTarget SVGMetadataElement
-instance IsGObject SVGMetadataElement where
-  toGObject = GObject . unSVGMetadataElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SVGMetadataElement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSVGMetadataElement :: IsGObject obj => obj -> IO SVGMetadataElement
-castToSVGMetadataElement = castTo gTypeSVGMetadataElement "SVGMetadataElement"
-
-foreign import javascript unsafe "window[\"SVGMetadataElement\"]" gTypeSVGMetadataElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SVGMissingGlyphElement".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.SVGElement"
---     * "GHCJS.DOM.Element"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SVGMissingGlyphElement Mozilla SVGMissingGlyphElement documentation>
-newtype SVGMissingGlyphElement = SVGMissingGlyphElement { unSVGMissingGlyphElement :: JSVal }
-
-instance Eq (SVGMissingGlyphElement) where
-  (SVGMissingGlyphElement a) == (SVGMissingGlyphElement b) = js_eq a b
-
-instance PToJSVal SVGMissingGlyphElement where
-  pToJSVal = unSVGMissingGlyphElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SVGMissingGlyphElement where
-  pFromJSVal = SVGMissingGlyphElement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SVGMissingGlyphElement where
-  toJSVal = return . unSVGMissingGlyphElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SVGMissingGlyphElement where
-  fromJSVal = return . fmap SVGMissingGlyphElement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsSVGElement SVGMissingGlyphElement
-instance IsElement SVGMissingGlyphElement
-instance IsNode SVGMissingGlyphElement
-instance IsEventTarget SVGMissingGlyphElement
-instance IsGObject SVGMissingGlyphElement where
-  toGObject = GObject . unSVGMissingGlyphElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SVGMissingGlyphElement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSVGMissingGlyphElement :: IsGObject obj => obj -> IO SVGMissingGlyphElement
-castToSVGMissingGlyphElement = castTo gTypeSVGMissingGlyphElement "SVGMissingGlyphElement"
-
-foreign import javascript unsafe "window[\"SVGMissingGlyphElement\"]" gTypeSVGMissingGlyphElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SVGNumber".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SVGNumber Mozilla SVGNumber documentation>
-newtype SVGNumber = SVGNumber { unSVGNumber :: JSVal }
-
-instance Eq (SVGNumber) where
-  (SVGNumber a) == (SVGNumber b) = js_eq a b
-
-instance PToJSVal SVGNumber where
-  pToJSVal = unSVGNumber
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SVGNumber where
-  pFromJSVal = SVGNumber
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SVGNumber where
-  toJSVal = return . unSVGNumber
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SVGNumber where
-  fromJSVal = return . fmap SVGNumber . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject SVGNumber where
-  toGObject = GObject . unSVGNumber
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SVGNumber . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSVGNumber :: IsGObject obj => obj -> IO SVGNumber
-castToSVGNumber = castTo gTypeSVGNumber "SVGNumber"
-
-foreign import javascript unsafe "window[\"SVGNumber\"]" gTypeSVGNumber :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SVGNumberList".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SVGNumberList Mozilla SVGNumberList documentation>
-newtype SVGNumberList = SVGNumberList { unSVGNumberList :: JSVal }
-
-instance Eq (SVGNumberList) where
-  (SVGNumberList a) == (SVGNumberList b) = js_eq a b
-
-instance PToJSVal SVGNumberList where
-  pToJSVal = unSVGNumberList
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SVGNumberList where
-  pFromJSVal = SVGNumberList
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SVGNumberList where
-  toJSVal = return . unSVGNumberList
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SVGNumberList where
-  fromJSVal = return . fmap SVGNumberList . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject SVGNumberList where
-  toGObject = GObject . unSVGNumberList
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SVGNumberList . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSVGNumberList :: IsGObject obj => obj -> IO SVGNumberList
-castToSVGNumberList = castTo gTypeSVGNumberList "SVGNumberList"
-
-foreign import javascript unsafe "window[\"SVGNumberList\"]" gTypeSVGNumberList :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SVGPaint".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.SVGColor"
---     * "GHCJS.DOM.CSSValue"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SVGPaint Mozilla SVGPaint documentation>
-newtype SVGPaint = SVGPaint { unSVGPaint :: JSVal }
-
-instance Eq (SVGPaint) where
-  (SVGPaint a) == (SVGPaint b) = js_eq a b
-
-instance PToJSVal SVGPaint where
-  pToJSVal = unSVGPaint
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SVGPaint where
-  pFromJSVal = SVGPaint
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SVGPaint where
-  toJSVal = return . unSVGPaint
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SVGPaint where
-  fromJSVal = return . fmap SVGPaint . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsSVGColor SVGPaint
-instance IsCSSValue SVGPaint
-instance IsGObject SVGPaint where
-  toGObject = GObject . unSVGPaint
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SVGPaint . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSVGPaint :: IsGObject obj => obj -> IO SVGPaint
-castToSVGPaint = castTo gTypeSVGPaint "SVGPaint"
-
-foreign import javascript unsafe "window[\"SVGPaint\"]" gTypeSVGPaint :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SVGPathElement".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.SVGGraphicsElement"
---     * "GHCJS.DOM.SVGElement"
---     * "GHCJS.DOM.Element"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathElement Mozilla SVGPathElement documentation>
-newtype SVGPathElement = SVGPathElement { unSVGPathElement :: JSVal }
-
-instance Eq (SVGPathElement) where
-  (SVGPathElement a) == (SVGPathElement b) = js_eq a b
-
-instance PToJSVal SVGPathElement where
-  pToJSVal = unSVGPathElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SVGPathElement where
-  pFromJSVal = SVGPathElement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SVGPathElement where
-  toJSVal = return . unSVGPathElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SVGPathElement where
-  fromJSVal = return . fmap SVGPathElement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsSVGGraphicsElement SVGPathElement
-instance IsSVGElement SVGPathElement
-instance IsElement SVGPathElement
-instance IsNode SVGPathElement
-instance IsEventTarget SVGPathElement
-instance IsGObject SVGPathElement where
-  toGObject = GObject . unSVGPathElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SVGPathElement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSVGPathElement :: IsGObject obj => obj -> IO SVGPathElement
-castToSVGPathElement = castTo gTypeSVGPathElement "SVGPathElement"
-
-foreign import javascript unsafe "window[\"SVGPathElement\"]" gTypeSVGPathElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SVGPathSeg".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathSeg Mozilla SVGPathSeg documentation>
-newtype SVGPathSeg = SVGPathSeg { unSVGPathSeg :: JSVal }
-
-instance Eq (SVGPathSeg) where
-  (SVGPathSeg a) == (SVGPathSeg b) = js_eq a b
-
-instance PToJSVal SVGPathSeg where
-  pToJSVal = unSVGPathSeg
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SVGPathSeg where
-  pFromJSVal = SVGPathSeg
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SVGPathSeg where
-  toJSVal = return . unSVGPathSeg
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SVGPathSeg where
-  fromJSVal = return . fmap SVGPathSeg . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-class IsGObject o => IsSVGPathSeg o
-toSVGPathSeg :: IsSVGPathSeg o => o -> SVGPathSeg
-toSVGPathSeg = unsafeCastGObject . toGObject
-
-instance IsSVGPathSeg SVGPathSeg
-instance IsGObject SVGPathSeg where
-  toGObject = GObject . unSVGPathSeg
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SVGPathSeg . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSVGPathSeg :: IsGObject obj => obj -> IO SVGPathSeg
-castToSVGPathSeg = castTo gTypeSVGPathSeg "SVGPathSeg"
-
-foreign import javascript unsafe "window[\"SVGPathSeg\"]" gTypeSVGPathSeg :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SVGPathSegArcAbs".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.SVGPathSeg"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathSegArcAbs Mozilla SVGPathSegArcAbs documentation>
-newtype SVGPathSegArcAbs = SVGPathSegArcAbs { unSVGPathSegArcAbs :: JSVal }
-
-instance Eq (SVGPathSegArcAbs) where
-  (SVGPathSegArcAbs a) == (SVGPathSegArcAbs b) = js_eq a b
-
-instance PToJSVal SVGPathSegArcAbs where
-  pToJSVal = unSVGPathSegArcAbs
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SVGPathSegArcAbs where
-  pFromJSVal = SVGPathSegArcAbs
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SVGPathSegArcAbs where
-  toJSVal = return . unSVGPathSegArcAbs
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SVGPathSegArcAbs where
-  fromJSVal = return . fmap SVGPathSegArcAbs . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsSVGPathSeg SVGPathSegArcAbs
-instance IsGObject SVGPathSegArcAbs where
-  toGObject = GObject . unSVGPathSegArcAbs
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SVGPathSegArcAbs . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSVGPathSegArcAbs :: IsGObject obj => obj -> IO SVGPathSegArcAbs
-castToSVGPathSegArcAbs = castTo gTypeSVGPathSegArcAbs "SVGPathSegArcAbs"
-
-foreign import javascript unsafe "window[\"SVGPathSegArcAbs\"]" gTypeSVGPathSegArcAbs :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SVGPathSegArcRel".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.SVGPathSeg"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathSegArcRel Mozilla SVGPathSegArcRel documentation>
-newtype SVGPathSegArcRel = SVGPathSegArcRel { unSVGPathSegArcRel :: JSVal }
-
-instance Eq (SVGPathSegArcRel) where
-  (SVGPathSegArcRel a) == (SVGPathSegArcRel b) = js_eq a b
-
-instance PToJSVal SVGPathSegArcRel where
-  pToJSVal = unSVGPathSegArcRel
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SVGPathSegArcRel where
-  pFromJSVal = SVGPathSegArcRel
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SVGPathSegArcRel where
-  toJSVal = return . unSVGPathSegArcRel
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SVGPathSegArcRel where
-  fromJSVal = return . fmap SVGPathSegArcRel . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsSVGPathSeg SVGPathSegArcRel
-instance IsGObject SVGPathSegArcRel where
-  toGObject = GObject . unSVGPathSegArcRel
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SVGPathSegArcRel . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSVGPathSegArcRel :: IsGObject obj => obj -> IO SVGPathSegArcRel
-castToSVGPathSegArcRel = castTo gTypeSVGPathSegArcRel "SVGPathSegArcRel"
-
-foreign import javascript unsafe "window[\"SVGPathSegArcRel\"]" gTypeSVGPathSegArcRel :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SVGPathSegClosePath".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.SVGPathSeg"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathSegClosePath Mozilla SVGPathSegClosePath documentation>
-newtype SVGPathSegClosePath = SVGPathSegClosePath { unSVGPathSegClosePath :: JSVal }
-
-instance Eq (SVGPathSegClosePath) where
-  (SVGPathSegClosePath a) == (SVGPathSegClosePath b) = js_eq a b
-
-instance PToJSVal SVGPathSegClosePath where
-  pToJSVal = unSVGPathSegClosePath
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SVGPathSegClosePath where
-  pFromJSVal = SVGPathSegClosePath
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SVGPathSegClosePath where
-  toJSVal = return . unSVGPathSegClosePath
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SVGPathSegClosePath where
-  fromJSVal = return . fmap SVGPathSegClosePath . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsSVGPathSeg SVGPathSegClosePath
-instance IsGObject SVGPathSegClosePath where
-  toGObject = GObject . unSVGPathSegClosePath
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SVGPathSegClosePath . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSVGPathSegClosePath :: IsGObject obj => obj -> IO SVGPathSegClosePath
-castToSVGPathSegClosePath = castTo gTypeSVGPathSegClosePath "SVGPathSegClosePath"
-
-foreign import javascript unsafe "window[\"SVGPathSegClosePath\"]" gTypeSVGPathSegClosePath :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SVGPathSegCurvetoCubicAbs".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.SVGPathSeg"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathSegCurvetoCubicAbs Mozilla SVGPathSegCurvetoCubicAbs documentation>
-newtype SVGPathSegCurvetoCubicAbs = SVGPathSegCurvetoCubicAbs { unSVGPathSegCurvetoCubicAbs :: JSVal }
-
-instance Eq (SVGPathSegCurvetoCubicAbs) where
-  (SVGPathSegCurvetoCubicAbs a) == (SVGPathSegCurvetoCubicAbs b) = js_eq a b
-
-instance PToJSVal SVGPathSegCurvetoCubicAbs where
-  pToJSVal = unSVGPathSegCurvetoCubicAbs
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SVGPathSegCurvetoCubicAbs where
-  pFromJSVal = SVGPathSegCurvetoCubicAbs
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SVGPathSegCurvetoCubicAbs where
-  toJSVal = return . unSVGPathSegCurvetoCubicAbs
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SVGPathSegCurvetoCubicAbs where
-  fromJSVal = return . fmap SVGPathSegCurvetoCubicAbs . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsSVGPathSeg SVGPathSegCurvetoCubicAbs
-instance IsGObject SVGPathSegCurvetoCubicAbs where
-  toGObject = GObject . unSVGPathSegCurvetoCubicAbs
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SVGPathSegCurvetoCubicAbs . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSVGPathSegCurvetoCubicAbs :: IsGObject obj => obj -> IO SVGPathSegCurvetoCubicAbs
-castToSVGPathSegCurvetoCubicAbs = castTo gTypeSVGPathSegCurvetoCubicAbs "SVGPathSegCurvetoCubicAbs"
-
-foreign import javascript unsafe "window[\"SVGPathSegCurvetoCubicAbs\"]" gTypeSVGPathSegCurvetoCubicAbs :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SVGPathSegCurvetoCubicRel".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.SVGPathSeg"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathSegCurvetoCubicRel Mozilla SVGPathSegCurvetoCubicRel documentation>
-newtype SVGPathSegCurvetoCubicRel = SVGPathSegCurvetoCubicRel { unSVGPathSegCurvetoCubicRel :: JSVal }
-
-instance Eq (SVGPathSegCurvetoCubicRel) where
-  (SVGPathSegCurvetoCubicRel a) == (SVGPathSegCurvetoCubicRel b) = js_eq a b
-
-instance PToJSVal SVGPathSegCurvetoCubicRel where
-  pToJSVal = unSVGPathSegCurvetoCubicRel
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SVGPathSegCurvetoCubicRel where
-  pFromJSVal = SVGPathSegCurvetoCubicRel
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SVGPathSegCurvetoCubicRel where
-  toJSVal = return . unSVGPathSegCurvetoCubicRel
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SVGPathSegCurvetoCubicRel where
-  fromJSVal = return . fmap SVGPathSegCurvetoCubicRel . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsSVGPathSeg SVGPathSegCurvetoCubicRel
-instance IsGObject SVGPathSegCurvetoCubicRel where
-  toGObject = GObject . unSVGPathSegCurvetoCubicRel
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SVGPathSegCurvetoCubicRel . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSVGPathSegCurvetoCubicRel :: IsGObject obj => obj -> IO SVGPathSegCurvetoCubicRel
-castToSVGPathSegCurvetoCubicRel = castTo gTypeSVGPathSegCurvetoCubicRel "SVGPathSegCurvetoCubicRel"
-
-foreign import javascript unsafe "window[\"SVGPathSegCurvetoCubicRel\"]" gTypeSVGPathSegCurvetoCubicRel :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SVGPathSegCurvetoCubicSmoothAbs".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.SVGPathSeg"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathSegCurvetoCubicSmoothAbs Mozilla SVGPathSegCurvetoCubicSmoothAbs documentation>
-newtype SVGPathSegCurvetoCubicSmoothAbs = SVGPathSegCurvetoCubicSmoothAbs { unSVGPathSegCurvetoCubicSmoothAbs :: JSVal }
-
-instance Eq (SVGPathSegCurvetoCubicSmoothAbs) where
-  (SVGPathSegCurvetoCubicSmoothAbs a) == (SVGPathSegCurvetoCubicSmoothAbs b) = js_eq a b
-
-instance PToJSVal SVGPathSegCurvetoCubicSmoothAbs where
-  pToJSVal = unSVGPathSegCurvetoCubicSmoothAbs
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SVGPathSegCurvetoCubicSmoothAbs where
-  pFromJSVal = SVGPathSegCurvetoCubicSmoothAbs
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SVGPathSegCurvetoCubicSmoothAbs where
-  toJSVal = return . unSVGPathSegCurvetoCubicSmoothAbs
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SVGPathSegCurvetoCubicSmoothAbs where
-  fromJSVal = return . fmap SVGPathSegCurvetoCubicSmoothAbs . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsSVGPathSeg SVGPathSegCurvetoCubicSmoothAbs
-instance IsGObject SVGPathSegCurvetoCubicSmoothAbs where
-  toGObject = GObject . unSVGPathSegCurvetoCubicSmoothAbs
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SVGPathSegCurvetoCubicSmoothAbs . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSVGPathSegCurvetoCubicSmoothAbs :: IsGObject obj => obj -> IO SVGPathSegCurvetoCubicSmoothAbs
-castToSVGPathSegCurvetoCubicSmoothAbs = castTo gTypeSVGPathSegCurvetoCubicSmoothAbs "SVGPathSegCurvetoCubicSmoothAbs"
-
-foreign import javascript unsafe "window[\"SVGPathSegCurvetoCubicSmoothAbs\"]" gTypeSVGPathSegCurvetoCubicSmoothAbs :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SVGPathSegCurvetoCubicSmoothRel".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.SVGPathSeg"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathSegCurvetoCubicSmoothRel Mozilla SVGPathSegCurvetoCubicSmoothRel documentation>
-newtype SVGPathSegCurvetoCubicSmoothRel = SVGPathSegCurvetoCubicSmoothRel { unSVGPathSegCurvetoCubicSmoothRel :: JSVal }
-
-instance Eq (SVGPathSegCurvetoCubicSmoothRel) where
-  (SVGPathSegCurvetoCubicSmoothRel a) == (SVGPathSegCurvetoCubicSmoothRel b) = js_eq a b
-
-instance PToJSVal SVGPathSegCurvetoCubicSmoothRel where
-  pToJSVal = unSVGPathSegCurvetoCubicSmoothRel
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SVGPathSegCurvetoCubicSmoothRel where
-  pFromJSVal = SVGPathSegCurvetoCubicSmoothRel
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SVGPathSegCurvetoCubicSmoothRel where
-  toJSVal = return . unSVGPathSegCurvetoCubicSmoothRel
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SVGPathSegCurvetoCubicSmoothRel where
-  fromJSVal = return . fmap SVGPathSegCurvetoCubicSmoothRel . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsSVGPathSeg SVGPathSegCurvetoCubicSmoothRel
-instance IsGObject SVGPathSegCurvetoCubicSmoothRel where
-  toGObject = GObject . unSVGPathSegCurvetoCubicSmoothRel
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SVGPathSegCurvetoCubicSmoothRel . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSVGPathSegCurvetoCubicSmoothRel :: IsGObject obj => obj -> IO SVGPathSegCurvetoCubicSmoothRel
-castToSVGPathSegCurvetoCubicSmoothRel = castTo gTypeSVGPathSegCurvetoCubicSmoothRel "SVGPathSegCurvetoCubicSmoothRel"
-
-foreign import javascript unsafe "window[\"SVGPathSegCurvetoCubicSmoothRel\"]" gTypeSVGPathSegCurvetoCubicSmoothRel :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SVGPathSegCurvetoQuadraticAbs".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.SVGPathSeg"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathSegCurvetoQuadraticAbs Mozilla SVGPathSegCurvetoQuadraticAbs documentation>
-newtype SVGPathSegCurvetoQuadraticAbs = SVGPathSegCurvetoQuadraticAbs { unSVGPathSegCurvetoQuadraticAbs :: JSVal }
-
-instance Eq (SVGPathSegCurvetoQuadraticAbs) where
-  (SVGPathSegCurvetoQuadraticAbs a) == (SVGPathSegCurvetoQuadraticAbs b) = js_eq a b
-
-instance PToJSVal SVGPathSegCurvetoQuadraticAbs where
-  pToJSVal = unSVGPathSegCurvetoQuadraticAbs
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SVGPathSegCurvetoQuadraticAbs where
-  pFromJSVal = SVGPathSegCurvetoQuadraticAbs
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SVGPathSegCurvetoQuadraticAbs where
-  toJSVal = return . unSVGPathSegCurvetoQuadraticAbs
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SVGPathSegCurvetoQuadraticAbs where
-  fromJSVal = return . fmap SVGPathSegCurvetoQuadraticAbs . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsSVGPathSeg SVGPathSegCurvetoQuadraticAbs
-instance IsGObject SVGPathSegCurvetoQuadraticAbs where
-  toGObject = GObject . unSVGPathSegCurvetoQuadraticAbs
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SVGPathSegCurvetoQuadraticAbs . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSVGPathSegCurvetoQuadraticAbs :: IsGObject obj => obj -> IO SVGPathSegCurvetoQuadraticAbs
-castToSVGPathSegCurvetoQuadraticAbs = castTo gTypeSVGPathSegCurvetoQuadraticAbs "SVGPathSegCurvetoQuadraticAbs"
-
-foreign import javascript unsafe "window[\"SVGPathSegCurvetoQuadraticAbs\"]" gTypeSVGPathSegCurvetoQuadraticAbs :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SVGPathSegCurvetoQuadraticRel".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.SVGPathSeg"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathSegCurvetoQuadraticRel Mozilla SVGPathSegCurvetoQuadraticRel documentation>
-newtype SVGPathSegCurvetoQuadraticRel = SVGPathSegCurvetoQuadraticRel { unSVGPathSegCurvetoQuadraticRel :: JSVal }
-
-instance Eq (SVGPathSegCurvetoQuadraticRel) where
-  (SVGPathSegCurvetoQuadraticRel a) == (SVGPathSegCurvetoQuadraticRel b) = js_eq a b
-
-instance PToJSVal SVGPathSegCurvetoQuadraticRel where
-  pToJSVal = unSVGPathSegCurvetoQuadraticRel
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SVGPathSegCurvetoQuadraticRel where
-  pFromJSVal = SVGPathSegCurvetoQuadraticRel
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SVGPathSegCurvetoQuadraticRel where
-  toJSVal = return . unSVGPathSegCurvetoQuadraticRel
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SVGPathSegCurvetoQuadraticRel where
-  fromJSVal = return . fmap SVGPathSegCurvetoQuadraticRel . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsSVGPathSeg SVGPathSegCurvetoQuadraticRel
-instance IsGObject SVGPathSegCurvetoQuadraticRel where
-  toGObject = GObject . unSVGPathSegCurvetoQuadraticRel
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SVGPathSegCurvetoQuadraticRel . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSVGPathSegCurvetoQuadraticRel :: IsGObject obj => obj -> IO SVGPathSegCurvetoQuadraticRel
-castToSVGPathSegCurvetoQuadraticRel = castTo gTypeSVGPathSegCurvetoQuadraticRel "SVGPathSegCurvetoQuadraticRel"
-
-foreign import javascript unsafe "window[\"SVGPathSegCurvetoQuadraticRel\"]" gTypeSVGPathSegCurvetoQuadraticRel :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SVGPathSegCurvetoQuadraticSmoothAbs".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.SVGPathSeg"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathSegCurvetoQuadraticSmoothAbs Mozilla SVGPathSegCurvetoQuadraticSmoothAbs documentation>
-newtype SVGPathSegCurvetoQuadraticSmoothAbs = SVGPathSegCurvetoQuadraticSmoothAbs { unSVGPathSegCurvetoQuadraticSmoothAbs :: JSVal }
-
-instance Eq (SVGPathSegCurvetoQuadraticSmoothAbs) where
-  (SVGPathSegCurvetoQuadraticSmoothAbs a) == (SVGPathSegCurvetoQuadraticSmoothAbs b) = js_eq a b
-
-instance PToJSVal SVGPathSegCurvetoQuadraticSmoothAbs where
-  pToJSVal = unSVGPathSegCurvetoQuadraticSmoothAbs
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SVGPathSegCurvetoQuadraticSmoothAbs where
-  pFromJSVal = SVGPathSegCurvetoQuadraticSmoothAbs
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SVGPathSegCurvetoQuadraticSmoothAbs where
-  toJSVal = return . unSVGPathSegCurvetoQuadraticSmoothAbs
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SVGPathSegCurvetoQuadraticSmoothAbs where
-  fromJSVal = return . fmap SVGPathSegCurvetoQuadraticSmoothAbs . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsSVGPathSeg SVGPathSegCurvetoQuadraticSmoothAbs
-instance IsGObject SVGPathSegCurvetoQuadraticSmoothAbs where
-  toGObject = GObject . unSVGPathSegCurvetoQuadraticSmoothAbs
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SVGPathSegCurvetoQuadraticSmoothAbs . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSVGPathSegCurvetoQuadraticSmoothAbs :: IsGObject obj => obj -> IO SVGPathSegCurvetoQuadraticSmoothAbs
-castToSVGPathSegCurvetoQuadraticSmoothAbs = castTo gTypeSVGPathSegCurvetoQuadraticSmoothAbs "SVGPathSegCurvetoQuadraticSmoothAbs"
-
-foreign import javascript unsafe "window[\"SVGPathSegCurvetoQuadraticSmoothAbs\"]" gTypeSVGPathSegCurvetoQuadraticSmoothAbs :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SVGPathSegCurvetoQuadraticSmoothRel".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.SVGPathSeg"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathSegCurvetoQuadraticSmoothRel Mozilla SVGPathSegCurvetoQuadraticSmoothRel documentation>
-newtype SVGPathSegCurvetoQuadraticSmoothRel = SVGPathSegCurvetoQuadraticSmoothRel { unSVGPathSegCurvetoQuadraticSmoothRel :: JSVal }
-
-instance Eq (SVGPathSegCurvetoQuadraticSmoothRel) where
-  (SVGPathSegCurvetoQuadraticSmoothRel a) == (SVGPathSegCurvetoQuadraticSmoothRel b) = js_eq a b
-
-instance PToJSVal SVGPathSegCurvetoQuadraticSmoothRel where
-  pToJSVal = unSVGPathSegCurvetoQuadraticSmoothRel
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SVGPathSegCurvetoQuadraticSmoothRel where
-  pFromJSVal = SVGPathSegCurvetoQuadraticSmoothRel
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SVGPathSegCurvetoQuadraticSmoothRel where
-  toJSVal = return . unSVGPathSegCurvetoQuadraticSmoothRel
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SVGPathSegCurvetoQuadraticSmoothRel where
-  fromJSVal = return . fmap SVGPathSegCurvetoQuadraticSmoothRel . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsSVGPathSeg SVGPathSegCurvetoQuadraticSmoothRel
-instance IsGObject SVGPathSegCurvetoQuadraticSmoothRel where
-  toGObject = GObject . unSVGPathSegCurvetoQuadraticSmoothRel
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SVGPathSegCurvetoQuadraticSmoothRel . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSVGPathSegCurvetoQuadraticSmoothRel :: IsGObject obj => obj -> IO SVGPathSegCurvetoQuadraticSmoothRel
-castToSVGPathSegCurvetoQuadraticSmoothRel = castTo gTypeSVGPathSegCurvetoQuadraticSmoothRel "SVGPathSegCurvetoQuadraticSmoothRel"
-
-foreign import javascript unsafe "window[\"SVGPathSegCurvetoQuadraticSmoothRel\"]" gTypeSVGPathSegCurvetoQuadraticSmoothRel :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SVGPathSegLinetoAbs".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.SVGPathSeg"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathSegLinetoAbs Mozilla SVGPathSegLinetoAbs documentation>
-newtype SVGPathSegLinetoAbs = SVGPathSegLinetoAbs { unSVGPathSegLinetoAbs :: JSVal }
-
-instance Eq (SVGPathSegLinetoAbs) where
-  (SVGPathSegLinetoAbs a) == (SVGPathSegLinetoAbs b) = js_eq a b
-
-instance PToJSVal SVGPathSegLinetoAbs where
-  pToJSVal = unSVGPathSegLinetoAbs
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SVGPathSegLinetoAbs where
-  pFromJSVal = SVGPathSegLinetoAbs
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SVGPathSegLinetoAbs where
-  toJSVal = return . unSVGPathSegLinetoAbs
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SVGPathSegLinetoAbs where
-  fromJSVal = return . fmap SVGPathSegLinetoAbs . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsSVGPathSeg SVGPathSegLinetoAbs
-instance IsGObject SVGPathSegLinetoAbs where
-  toGObject = GObject . unSVGPathSegLinetoAbs
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SVGPathSegLinetoAbs . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSVGPathSegLinetoAbs :: IsGObject obj => obj -> IO SVGPathSegLinetoAbs
-castToSVGPathSegLinetoAbs = castTo gTypeSVGPathSegLinetoAbs "SVGPathSegLinetoAbs"
-
-foreign import javascript unsafe "window[\"SVGPathSegLinetoAbs\"]" gTypeSVGPathSegLinetoAbs :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SVGPathSegLinetoHorizontalAbs".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.SVGPathSeg"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathSegLinetoHorizontalAbs Mozilla SVGPathSegLinetoHorizontalAbs documentation>
-newtype SVGPathSegLinetoHorizontalAbs = SVGPathSegLinetoHorizontalAbs { unSVGPathSegLinetoHorizontalAbs :: JSVal }
-
-instance Eq (SVGPathSegLinetoHorizontalAbs) where
-  (SVGPathSegLinetoHorizontalAbs a) == (SVGPathSegLinetoHorizontalAbs b) = js_eq a b
-
-instance PToJSVal SVGPathSegLinetoHorizontalAbs where
-  pToJSVal = unSVGPathSegLinetoHorizontalAbs
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SVGPathSegLinetoHorizontalAbs where
-  pFromJSVal = SVGPathSegLinetoHorizontalAbs
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SVGPathSegLinetoHorizontalAbs where
-  toJSVal = return . unSVGPathSegLinetoHorizontalAbs
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SVGPathSegLinetoHorizontalAbs where
-  fromJSVal = return . fmap SVGPathSegLinetoHorizontalAbs . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsSVGPathSeg SVGPathSegLinetoHorizontalAbs
-instance IsGObject SVGPathSegLinetoHorizontalAbs where
-  toGObject = GObject . unSVGPathSegLinetoHorizontalAbs
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SVGPathSegLinetoHorizontalAbs . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSVGPathSegLinetoHorizontalAbs :: IsGObject obj => obj -> IO SVGPathSegLinetoHorizontalAbs
-castToSVGPathSegLinetoHorizontalAbs = castTo gTypeSVGPathSegLinetoHorizontalAbs "SVGPathSegLinetoHorizontalAbs"
-
-foreign import javascript unsafe "window[\"SVGPathSegLinetoHorizontalAbs\"]" gTypeSVGPathSegLinetoHorizontalAbs :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SVGPathSegLinetoHorizontalRel".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.SVGPathSeg"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathSegLinetoHorizontalRel Mozilla SVGPathSegLinetoHorizontalRel documentation>
-newtype SVGPathSegLinetoHorizontalRel = SVGPathSegLinetoHorizontalRel { unSVGPathSegLinetoHorizontalRel :: JSVal }
-
-instance Eq (SVGPathSegLinetoHorizontalRel) where
-  (SVGPathSegLinetoHorizontalRel a) == (SVGPathSegLinetoHorizontalRel b) = js_eq a b
-
-instance PToJSVal SVGPathSegLinetoHorizontalRel where
-  pToJSVal = unSVGPathSegLinetoHorizontalRel
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SVGPathSegLinetoHorizontalRel where
-  pFromJSVal = SVGPathSegLinetoHorizontalRel
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SVGPathSegLinetoHorizontalRel where
-  toJSVal = return . unSVGPathSegLinetoHorizontalRel
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SVGPathSegLinetoHorizontalRel where
-  fromJSVal = return . fmap SVGPathSegLinetoHorizontalRel . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsSVGPathSeg SVGPathSegLinetoHorizontalRel
-instance IsGObject SVGPathSegLinetoHorizontalRel where
-  toGObject = GObject . unSVGPathSegLinetoHorizontalRel
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SVGPathSegLinetoHorizontalRel . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSVGPathSegLinetoHorizontalRel :: IsGObject obj => obj -> IO SVGPathSegLinetoHorizontalRel
-castToSVGPathSegLinetoHorizontalRel = castTo gTypeSVGPathSegLinetoHorizontalRel "SVGPathSegLinetoHorizontalRel"
-
-foreign import javascript unsafe "window[\"SVGPathSegLinetoHorizontalRel\"]" gTypeSVGPathSegLinetoHorizontalRel :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SVGPathSegLinetoRel".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.SVGPathSeg"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathSegLinetoRel Mozilla SVGPathSegLinetoRel documentation>
-newtype SVGPathSegLinetoRel = SVGPathSegLinetoRel { unSVGPathSegLinetoRel :: JSVal }
-
-instance Eq (SVGPathSegLinetoRel) where
-  (SVGPathSegLinetoRel a) == (SVGPathSegLinetoRel b) = js_eq a b
-
-instance PToJSVal SVGPathSegLinetoRel where
-  pToJSVal = unSVGPathSegLinetoRel
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SVGPathSegLinetoRel where
-  pFromJSVal = SVGPathSegLinetoRel
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SVGPathSegLinetoRel where
-  toJSVal = return . unSVGPathSegLinetoRel
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SVGPathSegLinetoRel where
-  fromJSVal = return . fmap SVGPathSegLinetoRel . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsSVGPathSeg SVGPathSegLinetoRel
-instance IsGObject SVGPathSegLinetoRel where
-  toGObject = GObject . unSVGPathSegLinetoRel
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SVGPathSegLinetoRel . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSVGPathSegLinetoRel :: IsGObject obj => obj -> IO SVGPathSegLinetoRel
-castToSVGPathSegLinetoRel = castTo gTypeSVGPathSegLinetoRel "SVGPathSegLinetoRel"
-
-foreign import javascript unsafe "window[\"SVGPathSegLinetoRel\"]" gTypeSVGPathSegLinetoRel :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SVGPathSegLinetoVerticalAbs".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.SVGPathSeg"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathSegLinetoVerticalAbs Mozilla SVGPathSegLinetoVerticalAbs documentation>
-newtype SVGPathSegLinetoVerticalAbs = SVGPathSegLinetoVerticalAbs { unSVGPathSegLinetoVerticalAbs :: JSVal }
-
-instance Eq (SVGPathSegLinetoVerticalAbs) where
-  (SVGPathSegLinetoVerticalAbs a) == (SVGPathSegLinetoVerticalAbs b) = js_eq a b
-
-instance PToJSVal SVGPathSegLinetoVerticalAbs where
-  pToJSVal = unSVGPathSegLinetoVerticalAbs
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SVGPathSegLinetoVerticalAbs where
-  pFromJSVal = SVGPathSegLinetoVerticalAbs
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SVGPathSegLinetoVerticalAbs where
-  toJSVal = return . unSVGPathSegLinetoVerticalAbs
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SVGPathSegLinetoVerticalAbs where
-  fromJSVal = return . fmap SVGPathSegLinetoVerticalAbs . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsSVGPathSeg SVGPathSegLinetoVerticalAbs
-instance IsGObject SVGPathSegLinetoVerticalAbs where
-  toGObject = GObject . unSVGPathSegLinetoVerticalAbs
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SVGPathSegLinetoVerticalAbs . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSVGPathSegLinetoVerticalAbs :: IsGObject obj => obj -> IO SVGPathSegLinetoVerticalAbs
-castToSVGPathSegLinetoVerticalAbs = castTo gTypeSVGPathSegLinetoVerticalAbs "SVGPathSegLinetoVerticalAbs"
-
-foreign import javascript unsafe "window[\"SVGPathSegLinetoVerticalAbs\"]" gTypeSVGPathSegLinetoVerticalAbs :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SVGPathSegLinetoVerticalRel".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.SVGPathSeg"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathSegLinetoVerticalRel Mozilla SVGPathSegLinetoVerticalRel documentation>
-newtype SVGPathSegLinetoVerticalRel = SVGPathSegLinetoVerticalRel { unSVGPathSegLinetoVerticalRel :: JSVal }
-
-instance Eq (SVGPathSegLinetoVerticalRel) where
-  (SVGPathSegLinetoVerticalRel a) == (SVGPathSegLinetoVerticalRel b) = js_eq a b
-
-instance PToJSVal SVGPathSegLinetoVerticalRel where
-  pToJSVal = unSVGPathSegLinetoVerticalRel
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SVGPathSegLinetoVerticalRel where
-  pFromJSVal = SVGPathSegLinetoVerticalRel
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SVGPathSegLinetoVerticalRel where
-  toJSVal = return . unSVGPathSegLinetoVerticalRel
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SVGPathSegLinetoVerticalRel where
-  fromJSVal = return . fmap SVGPathSegLinetoVerticalRel . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsSVGPathSeg SVGPathSegLinetoVerticalRel
-instance IsGObject SVGPathSegLinetoVerticalRel where
-  toGObject = GObject . unSVGPathSegLinetoVerticalRel
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SVGPathSegLinetoVerticalRel . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSVGPathSegLinetoVerticalRel :: IsGObject obj => obj -> IO SVGPathSegLinetoVerticalRel
-castToSVGPathSegLinetoVerticalRel = castTo gTypeSVGPathSegLinetoVerticalRel "SVGPathSegLinetoVerticalRel"
-
-foreign import javascript unsafe "window[\"SVGPathSegLinetoVerticalRel\"]" gTypeSVGPathSegLinetoVerticalRel :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SVGPathSegList".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathSegList Mozilla SVGPathSegList documentation>
-newtype SVGPathSegList = SVGPathSegList { unSVGPathSegList :: JSVal }
-
-instance Eq (SVGPathSegList) where
-  (SVGPathSegList a) == (SVGPathSegList b) = js_eq a b
-
-instance PToJSVal SVGPathSegList where
-  pToJSVal = unSVGPathSegList
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SVGPathSegList where
-  pFromJSVal = SVGPathSegList
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SVGPathSegList where
-  toJSVal = return . unSVGPathSegList
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SVGPathSegList where
-  fromJSVal = return . fmap SVGPathSegList . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject SVGPathSegList where
-  toGObject = GObject . unSVGPathSegList
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SVGPathSegList . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSVGPathSegList :: IsGObject obj => obj -> IO SVGPathSegList
-castToSVGPathSegList = castTo gTypeSVGPathSegList "SVGPathSegList"
-
-foreign import javascript unsafe "window[\"SVGPathSegList\"]" gTypeSVGPathSegList :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SVGPathSegMovetoAbs".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.SVGPathSeg"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathSegMovetoAbs Mozilla SVGPathSegMovetoAbs documentation>
-newtype SVGPathSegMovetoAbs = SVGPathSegMovetoAbs { unSVGPathSegMovetoAbs :: JSVal }
-
-instance Eq (SVGPathSegMovetoAbs) where
-  (SVGPathSegMovetoAbs a) == (SVGPathSegMovetoAbs b) = js_eq a b
-
-instance PToJSVal SVGPathSegMovetoAbs where
-  pToJSVal = unSVGPathSegMovetoAbs
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SVGPathSegMovetoAbs where
-  pFromJSVal = SVGPathSegMovetoAbs
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SVGPathSegMovetoAbs where
-  toJSVal = return . unSVGPathSegMovetoAbs
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SVGPathSegMovetoAbs where
-  fromJSVal = return . fmap SVGPathSegMovetoAbs . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsSVGPathSeg SVGPathSegMovetoAbs
-instance IsGObject SVGPathSegMovetoAbs where
-  toGObject = GObject . unSVGPathSegMovetoAbs
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SVGPathSegMovetoAbs . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSVGPathSegMovetoAbs :: IsGObject obj => obj -> IO SVGPathSegMovetoAbs
-castToSVGPathSegMovetoAbs = castTo gTypeSVGPathSegMovetoAbs "SVGPathSegMovetoAbs"
-
-foreign import javascript unsafe "window[\"SVGPathSegMovetoAbs\"]" gTypeSVGPathSegMovetoAbs :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SVGPathSegMovetoRel".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.SVGPathSeg"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathSegMovetoRel Mozilla SVGPathSegMovetoRel documentation>
-newtype SVGPathSegMovetoRel = SVGPathSegMovetoRel { unSVGPathSegMovetoRel :: JSVal }
-
-instance Eq (SVGPathSegMovetoRel) where
-  (SVGPathSegMovetoRel a) == (SVGPathSegMovetoRel b) = js_eq a b
-
-instance PToJSVal SVGPathSegMovetoRel where
-  pToJSVal = unSVGPathSegMovetoRel
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SVGPathSegMovetoRel where
-  pFromJSVal = SVGPathSegMovetoRel
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SVGPathSegMovetoRel where
-  toJSVal = return . unSVGPathSegMovetoRel
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SVGPathSegMovetoRel where
-  fromJSVal = return . fmap SVGPathSegMovetoRel . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsSVGPathSeg SVGPathSegMovetoRel
-instance IsGObject SVGPathSegMovetoRel where
-  toGObject = GObject . unSVGPathSegMovetoRel
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SVGPathSegMovetoRel . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSVGPathSegMovetoRel :: IsGObject obj => obj -> IO SVGPathSegMovetoRel
-castToSVGPathSegMovetoRel = castTo gTypeSVGPathSegMovetoRel "SVGPathSegMovetoRel"
-
-foreign import javascript unsafe "window[\"SVGPathSegMovetoRel\"]" gTypeSVGPathSegMovetoRel :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SVGPatternElement".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.SVGElement"
---     * "GHCJS.DOM.Element"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SVGPatternElement Mozilla SVGPatternElement documentation>
-newtype SVGPatternElement = SVGPatternElement { unSVGPatternElement :: JSVal }
-
-instance Eq (SVGPatternElement) where
-  (SVGPatternElement a) == (SVGPatternElement b) = js_eq a b
-
-instance PToJSVal SVGPatternElement where
-  pToJSVal = unSVGPatternElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SVGPatternElement where
-  pFromJSVal = SVGPatternElement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SVGPatternElement where
-  toJSVal = return . unSVGPatternElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SVGPatternElement where
-  fromJSVal = return . fmap SVGPatternElement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsSVGElement SVGPatternElement
-instance IsElement SVGPatternElement
-instance IsNode SVGPatternElement
-instance IsEventTarget SVGPatternElement
-instance IsGObject SVGPatternElement where
-  toGObject = GObject . unSVGPatternElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SVGPatternElement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSVGPatternElement :: IsGObject obj => obj -> IO SVGPatternElement
-castToSVGPatternElement = castTo gTypeSVGPatternElement "SVGPatternElement"
-
-foreign import javascript unsafe "window[\"SVGPatternElement\"]" gTypeSVGPatternElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SVGPoint".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SVGPoint Mozilla SVGPoint documentation>
-newtype SVGPoint = SVGPoint { unSVGPoint :: JSVal }
-
-instance Eq (SVGPoint) where
-  (SVGPoint a) == (SVGPoint b) = js_eq a b
-
-instance PToJSVal SVGPoint where
-  pToJSVal = unSVGPoint
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SVGPoint where
-  pFromJSVal = SVGPoint
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SVGPoint where
-  toJSVal = return . unSVGPoint
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SVGPoint where
-  fromJSVal = return . fmap SVGPoint . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject SVGPoint where
-  toGObject = GObject . unSVGPoint
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SVGPoint . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSVGPoint :: IsGObject obj => obj -> IO SVGPoint
-castToSVGPoint = castTo gTypeSVGPoint "SVGPoint"
-
-foreign import javascript unsafe "window[\"SVGPoint\"]" gTypeSVGPoint :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SVGPointList".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SVGPointList Mozilla SVGPointList documentation>
-newtype SVGPointList = SVGPointList { unSVGPointList :: JSVal }
-
-instance Eq (SVGPointList) where
-  (SVGPointList a) == (SVGPointList b) = js_eq a b
-
-instance PToJSVal SVGPointList where
-  pToJSVal = unSVGPointList
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SVGPointList where
-  pFromJSVal = SVGPointList
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SVGPointList where
-  toJSVal = return . unSVGPointList
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SVGPointList where
-  fromJSVal = return . fmap SVGPointList . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject SVGPointList where
-  toGObject = GObject . unSVGPointList
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SVGPointList . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSVGPointList :: IsGObject obj => obj -> IO SVGPointList
-castToSVGPointList = castTo gTypeSVGPointList "SVGPointList"
-
-foreign import javascript unsafe "window[\"SVGPointList\"]" gTypeSVGPointList :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SVGPolygonElement".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.SVGGraphicsElement"
---     * "GHCJS.DOM.SVGElement"
---     * "GHCJS.DOM.Element"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SVGPolygonElement Mozilla SVGPolygonElement documentation>
-newtype SVGPolygonElement = SVGPolygonElement { unSVGPolygonElement :: JSVal }
-
-instance Eq (SVGPolygonElement) where
-  (SVGPolygonElement a) == (SVGPolygonElement b) = js_eq a b
-
-instance PToJSVal SVGPolygonElement where
-  pToJSVal = unSVGPolygonElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SVGPolygonElement where
-  pFromJSVal = SVGPolygonElement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SVGPolygonElement where
-  toJSVal = return . unSVGPolygonElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SVGPolygonElement where
-  fromJSVal = return . fmap SVGPolygonElement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsSVGGraphicsElement SVGPolygonElement
-instance IsSVGElement SVGPolygonElement
-instance IsElement SVGPolygonElement
-instance IsNode SVGPolygonElement
-instance IsEventTarget SVGPolygonElement
-instance IsGObject SVGPolygonElement where
-  toGObject = GObject . unSVGPolygonElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SVGPolygonElement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSVGPolygonElement :: IsGObject obj => obj -> IO SVGPolygonElement
-castToSVGPolygonElement = castTo gTypeSVGPolygonElement "SVGPolygonElement"
-
-foreign import javascript unsafe "window[\"SVGPolygonElement\"]" gTypeSVGPolygonElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SVGPolylineElement".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.SVGGraphicsElement"
---     * "GHCJS.DOM.SVGElement"
---     * "GHCJS.DOM.Element"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SVGPolylineElement Mozilla SVGPolylineElement documentation>
-newtype SVGPolylineElement = SVGPolylineElement { unSVGPolylineElement :: JSVal }
-
-instance Eq (SVGPolylineElement) where
-  (SVGPolylineElement a) == (SVGPolylineElement b) = js_eq a b
-
-instance PToJSVal SVGPolylineElement where
-  pToJSVal = unSVGPolylineElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SVGPolylineElement where
-  pFromJSVal = SVGPolylineElement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SVGPolylineElement where
-  toJSVal = return . unSVGPolylineElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SVGPolylineElement where
-  fromJSVal = return . fmap SVGPolylineElement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsSVGGraphicsElement SVGPolylineElement
-instance IsSVGElement SVGPolylineElement
-instance IsElement SVGPolylineElement
-instance IsNode SVGPolylineElement
-instance IsEventTarget SVGPolylineElement
-instance IsGObject SVGPolylineElement where
-  toGObject = GObject . unSVGPolylineElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SVGPolylineElement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSVGPolylineElement :: IsGObject obj => obj -> IO SVGPolylineElement
-castToSVGPolylineElement = castTo gTypeSVGPolylineElement "SVGPolylineElement"
-
-foreign import javascript unsafe "window[\"SVGPolylineElement\"]" gTypeSVGPolylineElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SVGPreserveAspectRatio".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SVGPreserveAspectRatio Mozilla SVGPreserveAspectRatio documentation>
-newtype SVGPreserveAspectRatio = SVGPreserveAspectRatio { unSVGPreserveAspectRatio :: JSVal }
-
-instance Eq (SVGPreserveAspectRatio) where
-  (SVGPreserveAspectRatio a) == (SVGPreserveAspectRatio b) = js_eq a b
-
-instance PToJSVal SVGPreserveAspectRatio where
-  pToJSVal = unSVGPreserveAspectRatio
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SVGPreserveAspectRatio where
-  pFromJSVal = SVGPreserveAspectRatio
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SVGPreserveAspectRatio where
-  toJSVal = return . unSVGPreserveAspectRatio
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SVGPreserveAspectRatio where
-  fromJSVal = return . fmap SVGPreserveAspectRatio . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject SVGPreserveAspectRatio where
-  toGObject = GObject . unSVGPreserveAspectRatio
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SVGPreserveAspectRatio . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSVGPreserveAspectRatio :: IsGObject obj => obj -> IO SVGPreserveAspectRatio
-castToSVGPreserveAspectRatio = castTo gTypeSVGPreserveAspectRatio "SVGPreserveAspectRatio"
-
-foreign import javascript unsafe "window[\"SVGPreserveAspectRatio\"]" gTypeSVGPreserveAspectRatio :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SVGRadialGradientElement".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.SVGGradientElement"
---     * "GHCJS.DOM.SVGElement"
---     * "GHCJS.DOM.Element"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SVGRadialGradientElement Mozilla SVGRadialGradientElement documentation>
-newtype SVGRadialGradientElement = SVGRadialGradientElement { unSVGRadialGradientElement :: JSVal }
-
-instance Eq (SVGRadialGradientElement) where
-  (SVGRadialGradientElement a) == (SVGRadialGradientElement b) = js_eq a b
-
-instance PToJSVal SVGRadialGradientElement where
-  pToJSVal = unSVGRadialGradientElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SVGRadialGradientElement where
-  pFromJSVal = SVGRadialGradientElement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SVGRadialGradientElement where
-  toJSVal = return . unSVGRadialGradientElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SVGRadialGradientElement where
-  fromJSVal = return . fmap SVGRadialGradientElement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsSVGGradientElement SVGRadialGradientElement
-instance IsSVGElement SVGRadialGradientElement
-instance IsElement SVGRadialGradientElement
-instance IsNode SVGRadialGradientElement
-instance IsEventTarget SVGRadialGradientElement
-instance IsGObject SVGRadialGradientElement where
-  toGObject = GObject . unSVGRadialGradientElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SVGRadialGradientElement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSVGRadialGradientElement :: IsGObject obj => obj -> IO SVGRadialGradientElement
-castToSVGRadialGradientElement = castTo gTypeSVGRadialGradientElement "SVGRadialGradientElement"
-
-foreign import javascript unsafe "window[\"SVGRadialGradientElement\"]" gTypeSVGRadialGradientElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SVGRect".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SVGRect Mozilla SVGRect documentation>
-newtype SVGRect = SVGRect { unSVGRect :: JSVal }
-
-instance Eq (SVGRect) where
-  (SVGRect a) == (SVGRect b) = js_eq a b
-
-instance PToJSVal SVGRect where
-  pToJSVal = unSVGRect
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SVGRect where
-  pFromJSVal = SVGRect
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SVGRect where
-  toJSVal = return . unSVGRect
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SVGRect where
-  fromJSVal = return . fmap SVGRect . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject SVGRect where
-  toGObject = GObject . unSVGRect
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SVGRect . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSVGRect :: IsGObject obj => obj -> IO SVGRect
-castToSVGRect = castTo gTypeSVGRect "SVGRect"
-
-foreign import javascript unsafe "window[\"SVGRect\"]" gTypeSVGRect :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SVGRectElement".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.SVGGraphicsElement"
---     * "GHCJS.DOM.SVGElement"
---     * "GHCJS.DOM.Element"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SVGRectElement Mozilla SVGRectElement documentation>
-newtype SVGRectElement = SVGRectElement { unSVGRectElement :: JSVal }
-
-instance Eq (SVGRectElement) where
-  (SVGRectElement a) == (SVGRectElement b) = js_eq a b
-
-instance PToJSVal SVGRectElement where
-  pToJSVal = unSVGRectElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SVGRectElement where
-  pFromJSVal = SVGRectElement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SVGRectElement where
-  toJSVal = return . unSVGRectElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SVGRectElement where
-  fromJSVal = return . fmap SVGRectElement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsSVGGraphicsElement SVGRectElement
-instance IsSVGElement SVGRectElement
-instance IsElement SVGRectElement
-instance IsNode SVGRectElement
-instance IsEventTarget SVGRectElement
-instance IsGObject SVGRectElement where
-  toGObject = GObject . unSVGRectElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SVGRectElement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSVGRectElement :: IsGObject obj => obj -> IO SVGRectElement
-castToSVGRectElement = castTo gTypeSVGRectElement "SVGRectElement"
-
-foreign import javascript unsafe "window[\"SVGRectElement\"]" gTypeSVGRectElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SVGRenderingIntent".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SVGRenderingIntent Mozilla SVGRenderingIntent documentation>
-newtype SVGRenderingIntent = SVGRenderingIntent { unSVGRenderingIntent :: JSVal }
-
-instance Eq (SVGRenderingIntent) where
-  (SVGRenderingIntent a) == (SVGRenderingIntent b) = js_eq a b
-
-instance PToJSVal SVGRenderingIntent where
-  pToJSVal = unSVGRenderingIntent
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SVGRenderingIntent where
-  pFromJSVal = SVGRenderingIntent
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SVGRenderingIntent where
-  toJSVal = return . unSVGRenderingIntent
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SVGRenderingIntent where
-  fromJSVal = return . fmap SVGRenderingIntent . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject SVGRenderingIntent where
-  toGObject = GObject . unSVGRenderingIntent
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SVGRenderingIntent . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSVGRenderingIntent :: IsGObject obj => obj -> IO SVGRenderingIntent
-castToSVGRenderingIntent = castTo gTypeSVGRenderingIntent "SVGRenderingIntent"
-
-foreign import javascript unsafe "window[\"SVGRenderingIntent\"]" gTypeSVGRenderingIntent :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SVGSVGElement".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.SVGGraphicsElement"
---     * "GHCJS.DOM.SVGElement"
---     * "GHCJS.DOM.Element"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SVGSVGElement Mozilla SVGSVGElement documentation>
-newtype SVGSVGElement = SVGSVGElement { unSVGSVGElement :: JSVal }
-
-instance Eq (SVGSVGElement) where
-  (SVGSVGElement a) == (SVGSVGElement b) = js_eq a b
-
-instance PToJSVal SVGSVGElement where
-  pToJSVal = unSVGSVGElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SVGSVGElement where
-  pFromJSVal = SVGSVGElement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SVGSVGElement where
-  toJSVal = return . unSVGSVGElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SVGSVGElement where
-  fromJSVal = return . fmap SVGSVGElement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsSVGGraphicsElement SVGSVGElement
-instance IsSVGElement SVGSVGElement
-instance IsElement SVGSVGElement
-instance IsNode SVGSVGElement
-instance IsEventTarget SVGSVGElement
-instance IsGObject SVGSVGElement where
-  toGObject = GObject . unSVGSVGElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SVGSVGElement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSVGSVGElement :: IsGObject obj => obj -> IO SVGSVGElement
-castToSVGSVGElement = castTo gTypeSVGSVGElement "SVGSVGElement"
-
-foreign import javascript unsafe "window[\"SVGSVGElement\"]" gTypeSVGSVGElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SVGScriptElement".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.SVGElement"
---     * "GHCJS.DOM.Element"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SVGScriptElement Mozilla SVGScriptElement documentation>
-newtype SVGScriptElement = SVGScriptElement { unSVGScriptElement :: JSVal }
-
-instance Eq (SVGScriptElement) where
-  (SVGScriptElement a) == (SVGScriptElement b) = js_eq a b
-
-instance PToJSVal SVGScriptElement where
-  pToJSVal = unSVGScriptElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SVGScriptElement where
-  pFromJSVal = SVGScriptElement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SVGScriptElement where
-  toJSVal = return . unSVGScriptElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SVGScriptElement where
-  fromJSVal = return . fmap SVGScriptElement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsSVGElement SVGScriptElement
-instance IsElement SVGScriptElement
-instance IsNode SVGScriptElement
-instance IsEventTarget SVGScriptElement
-instance IsGObject SVGScriptElement where
-  toGObject = GObject . unSVGScriptElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SVGScriptElement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSVGScriptElement :: IsGObject obj => obj -> IO SVGScriptElement
-castToSVGScriptElement = castTo gTypeSVGScriptElement "SVGScriptElement"
-
-foreign import javascript unsafe "window[\"SVGScriptElement\"]" gTypeSVGScriptElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SVGSetElement".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.SVGAnimationElement"
---     * "GHCJS.DOM.SVGElement"
---     * "GHCJS.DOM.Element"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SVGSetElement Mozilla SVGSetElement documentation>
-newtype SVGSetElement = SVGSetElement { unSVGSetElement :: JSVal }
-
-instance Eq (SVGSetElement) where
-  (SVGSetElement a) == (SVGSetElement b) = js_eq a b
-
-instance PToJSVal SVGSetElement where
-  pToJSVal = unSVGSetElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SVGSetElement where
-  pFromJSVal = SVGSetElement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SVGSetElement where
-  toJSVal = return . unSVGSetElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SVGSetElement where
-  fromJSVal = return . fmap SVGSetElement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsSVGAnimationElement SVGSetElement
-instance IsSVGElement SVGSetElement
-instance IsElement SVGSetElement
-instance IsNode SVGSetElement
-instance IsEventTarget SVGSetElement
-instance IsGObject SVGSetElement where
-  toGObject = GObject . unSVGSetElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SVGSetElement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSVGSetElement :: IsGObject obj => obj -> IO SVGSetElement
-castToSVGSetElement = castTo gTypeSVGSetElement "SVGSetElement"
-
-foreign import javascript unsafe "window[\"SVGSetElement\"]" gTypeSVGSetElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SVGStopElement".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.SVGElement"
---     * "GHCJS.DOM.Element"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SVGStopElement Mozilla SVGStopElement documentation>
-newtype SVGStopElement = SVGStopElement { unSVGStopElement :: JSVal }
-
-instance Eq (SVGStopElement) where
-  (SVGStopElement a) == (SVGStopElement b) = js_eq a b
-
-instance PToJSVal SVGStopElement where
-  pToJSVal = unSVGStopElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SVGStopElement where
-  pFromJSVal = SVGStopElement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SVGStopElement where
-  toJSVal = return . unSVGStopElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SVGStopElement where
-  fromJSVal = return . fmap SVGStopElement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsSVGElement SVGStopElement
-instance IsElement SVGStopElement
-instance IsNode SVGStopElement
-instance IsEventTarget SVGStopElement
-instance IsGObject SVGStopElement where
-  toGObject = GObject . unSVGStopElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SVGStopElement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSVGStopElement :: IsGObject obj => obj -> IO SVGStopElement
-castToSVGStopElement = castTo gTypeSVGStopElement "SVGStopElement"
-
-foreign import javascript unsafe "window[\"SVGStopElement\"]" gTypeSVGStopElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SVGStringList".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SVGStringList Mozilla SVGStringList documentation>
-newtype SVGStringList = SVGStringList { unSVGStringList :: JSVal }
-
-instance Eq (SVGStringList) where
-  (SVGStringList a) == (SVGStringList b) = js_eq a b
-
-instance PToJSVal SVGStringList where
-  pToJSVal = unSVGStringList
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SVGStringList where
-  pFromJSVal = SVGStringList
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SVGStringList where
-  toJSVal = return . unSVGStringList
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SVGStringList where
-  fromJSVal = return . fmap SVGStringList . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject SVGStringList where
-  toGObject = GObject . unSVGStringList
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SVGStringList . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSVGStringList :: IsGObject obj => obj -> IO SVGStringList
-castToSVGStringList = castTo gTypeSVGStringList "SVGStringList"
-
-foreign import javascript unsafe "window[\"SVGStringList\"]" gTypeSVGStringList :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SVGStyleElement".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.SVGElement"
---     * "GHCJS.DOM.Element"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SVGStyleElement Mozilla SVGStyleElement documentation>
-newtype SVGStyleElement = SVGStyleElement { unSVGStyleElement :: JSVal }
-
-instance Eq (SVGStyleElement) where
-  (SVGStyleElement a) == (SVGStyleElement b) = js_eq a b
-
-instance PToJSVal SVGStyleElement where
-  pToJSVal = unSVGStyleElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SVGStyleElement where
-  pFromJSVal = SVGStyleElement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SVGStyleElement where
-  toJSVal = return . unSVGStyleElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SVGStyleElement where
-  fromJSVal = return . fmap SVGStyleElement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsSVGElement SVGStyleElement
-instance IsElement SVGStyleElement
-instance IsNode SVGStyleElement
-instance IsEventTarget SVGStyleElement
-instance IsGObject SVGStyleElement where
-  toGObject = GObject . unSVGStyleElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SVGStyleElement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSVGStyleElement :: IsGObject obj => obj -> IO SVGStyleElement
-castToSVGStyleElement = castTo gTypeSVGStyleElement "SVGStyleElement"
-
-foreign import javascript unsafe "window[\"SVGStyleElement\"]" gTypeSVGStyleElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SVGSwitchElement".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.SVGGraphicsElement"
---     * "GHCJS.DOM.SVGElement"
---     * "GHCJS.DOM.Element"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SVGSwitchElement Mozilla SVGSwitchElement documentation>
-newtype SVGSwitchElement = SVGSwitchElement { unSVGSwitchElement :: JSVal }
-
-instance Eq (SVGSwitchElement) where
-  (SVGSwitchElement a) == (SVGSwitchElement b) = js_eq a b
-
-instance PToJSVal SVGSwitchElement where
-  pToJSVal = unSVGSwitchElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SVGSwitchElement where
-  pFromJSVal = SVGSwitchElement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SVGSwitchElement where
-  toJSVal = return . unSVGSwitchElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SVGSwitchElement where
-  fromJSVal = return . fmap SVGSwitchElement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsSVGGraphicsElement SVGSwitchElement
-instance IsSVGElement SVGSwitchElement
-instance IsElement SVGSwitchElement
-instance IsNode SVGSwitchElement
-instance IsEventTarget SVGSwitchElement
-instance IsGObject SVGSwitchElement where
-  toGObject = GObject . unSVGSwitchElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SVGSwitchElement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSVGSwitchElement :: IsGObject obj => obj -> IO SVGSwitchElement
-castToSVGSwitchElement = castTo gTypeSVGSwitchElement "SVGSwitchElement"
-
-foreign import javascript unsafe "window[\"SVGSwitchElement\"]" gTypeSVGSwitchElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SVGSymbolElement".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.SVGElement"
---     * "GHCJS.DOM.Element"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SVGSymbolElement Mozilla SVGSymbolElement documentation>
-newtype SVGSymbolElement = SVGSymbolElement { unSVGSymbolElement :: JSVal }
-
-instance Eq (SVGSymbolElement) where
-  (SVGSymbolElement a) == (SVGSymbolElement b) = js_eq a b
-
-instance PToJSVal SVGSymbolElement where
-  pToJSVal = unSVGSymbolElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SVGSymbolElement where
-  pFromJSVal = SVGSymbolElement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SVGSymbolElement where
-  toJSVal = return . unSVGSymbolElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SVGSymbolElement where
-  fromJSVal = return . fmap SVGSymbolElement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsSVGElement SVGSymbolElement
-instance IsElement SVGSymbolElement
-instance IsNode SVGSymbolElement
-instance IsEventTarget SVGSymbolElement
-instance IsGObject SVGSymbolElement where
-  toGObject = GObject . unSVGSymbolElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SVGSymbolElement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSVGSymbolElement :: IsGObject obj => obj -> IO SVGSymbolElement
-castToSVGSymbolElement = castTo gTypeSVGSymbolElement "SVGSymbolElement"
-
-foreign import javascript unsafe "window[\"SVGSymbolElement\"]" gTypeSVGSymbolElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SVGTRefElement".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.SVGTextPositioningElement"
---     * "GHCJS.DOM.SVGTextContentElement"
---     * "GHCJS.DOM.SVGGraphicsElement"
---     * "GHCJS.DOM.SVGElement"
---     * "GHCJS.DOM.Element"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SVGTRefElement Mozilla SVGTRefElement documentation>
-newtype SVGTRefElement = SVGTRefElement { unSVGTRefElement :: JSVal }
-
-instance Eq (SVGTRefElement) where
-  (SVGTRefElement a) == (SVGTRefElement b) = js_eq a b
-
-instance PToJSVal SVGTRefElement where
-  pToJSVal = unSVGTRefElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SVGTRefElement where
-  pFromJSVal = SVGTRefElement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SVGTRefElement where
-  toJSVal = return . unSVGTRefElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SVGTRefElement where
-  fromJSVal = return . fmap SVGTRefElement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsSVGTextPositioningElement SVGTRefElement
-instance IsSVGTextContentElement SVGTRefElement
-instance IsSVGGraphicsElement SVGTRefElement
-instance IsSVGElement SVGTRefElement
-instance IsElement SVGTRefElement
-instance IsNode SVGTRefElement
-instance IsEventTarget SVGTRefElement
-instance IsGObject SVGTRefElement where
-  toGObject = GObject . unSVGTRefElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SVGTRefElement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSVGTRefElement :: IsGObject obj => obj -> IO SVGTRefElement
-castToSVGTRefElement = castTo gTypeSVGTRefElement "SVGTRefElement"
-
-foreign import javascript unsafe "window[\"SVGTRefElement\"]" gTypeSVGTRefElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SVGTSpanElement".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.SVGTextPositioningElement"
---     * "GHCJS.DOM.SVGTextContentElement"
---     * "GHCJS.DOM.SVGGraphicsElement"
---     * "GHCJS.DOM.SVGElement"
---     * "GHCJS.DOM.Element"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SVGTSpanElement Mozilla SVGTSpanElement documentation>
-newtype SVGTSpanElement = SVGTSpanElement { unSVGTSpanElement :: JSVal }
-
-instance Eq (SVGTSpanElement) where
-  (SVGTSpanElement a) == (SVGTSpanElement b) = js_eq a b
-
-instance PToJSVal SVGTSpanElement where
-  pToJSVal = unSVGTSpanElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SVGTSpanElement where
-  pFromJSVal = SVGTSpanElement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SVGTSpanElement where
-  toJSVal = return . unSVGTSpanElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SVGTSpanElement where
-  fromJSVal = return . fmap SVGTSpanElement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsSVGTextPositioningElement SVGTSpanElement
-instance IsSVGTextContentElement SVGTSpanElement
-instance IsSVGGraphicsElement SVGTSpanElement
-instance IsSVGElement SVGTSpanElement
-instance IsElement SVGTSpanElement
-instance IsNode SVGTSpanElement
-instance IsEventTarget SVGTSpanElement
-instance IsGObject SVGTSpanElement where
-  toGObject = GObject . unSVGTSpanElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SVGTSpanElement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSVGTSpanElement :: IsGObject obj => obj -> IO SVGTSpanElement
-castToSVGTSpanElement = castTo gTypeSVGTSpanElement "SVGTSpanElement"
-
-foreign import javascript unsafe "window[\"SVGTSpanElement\"]" gTypeSVGTSpanElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SVGTests".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SVGTests Mozilla SVGTests documentation>
-newtype SVGTests = SVGTests { unSVGTests :: JSVal }
-
-instance Eq (SVGTests) where
-  (SVGTests a) == (SVGTests b) = js_eq a b
-
-instance PToJSVal SVGTests where
-  pToJSVal = unSVGTests
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SVGTests where
-  pFromJSVal = SVGTests
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SVGTests where
-  toJSVal = return . unSVGTests
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SVGTests where
-  fromJSVal = return . fmap SVGTests . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject SVGTests where
-  toGObject = GObject . unSVGTests
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SVGTests . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSVGTests :: IsGObject obj => obj -> IO SVGTests
-castToSVGTests = castTo gTypeSVGTests "SVGTests"
-
-foreign import javascript unsafe "window[\"SVGTests\"]" gTypeSVGTests :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SVGTextContentElement".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.SVGGraphicsElement"
---     * "GHCJS.DOM.SVGElement"
---     * "GHCJS.DOM.Element"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SVGTextContentElement Mozilla SVGTextContentElement documentation>
-newtype SVGTextContentElement = SVGTextContentElement { unSVGTextContentElement :: JSVal }
-
-instance Eq (SVGTextContentElement) where
-  (SVGTextContentElement a) == (SVGTextContentElement b) = js_eq a b
-
-instance PToJSVal SVGTextContentElement where
-  pToJSVal = unSVGTextContentElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SVGTextContentElement where
-  pFromJSVal = SVGTextContentElement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SVGTextContentElement where
-  toJSVal = return . unSVGTextContentElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SVGTextContentElement where
-  fromJSVal = return . fmap SVGTextContentElement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-class IsSVGGraphicsElement o => IsSVGTextContentElement o
-toSVGTextContentElement :: IsSVGTextContentElement o => o -> SVGTextContentElement
-toSVGTextContentElement = unsafeCastGObject . toGObject
-
-instance IsSVGTextContentElement SVGTextContentElement
-instance IsSVGGraphicsElement SVGTextContentElement
-instance IsSVGElement SVGTextContentElement
-instance IsElement SVGTextContentElement
-instance IsNode SVGTextContentElement
-instance IsEventTarget SVGTextContentElement
-instance IsGObject SVGTextContentElement where
-  toGObject = GObject . unSVGTextContentElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SVGTextContentElement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSVGTextContentElement :: IsGObject obj => obj -> IO SVGTextContentElement
-castToSVGTextContentElement = castTo gTypeSVGTextContentElement "SVGTextContentElement"
-
-foreign import javascript unsafe "window[\"SVGTextContentElement\"]" gTypeSVGTextContentElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SVGTextElement".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.SVGTextPositioningElement"
---     * "GHCJS.DOM.SVGTextContentElement"
---     * "GHCJS.DOM.SVGGraphicsElement"
---     * "GHCJS.DOM.SVGElement"
---     * "GHCJS.DOM.Element"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SVGTextElement Mozilla SVGTextElement documentation>
-newtype SVGTextElement = SVGTextElement { unSVGTextElement :: JSVal }
-
-instance Eq (SVGTextElement) where
-  (SVGTextElement a) == (SVGTextElement b) = js_eq a b
-
-instance PToJSVal SVGTextElement where
-  pToJSVal = unSVGTextElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SVGTextElement where
-  pFromJSVal = SVGTextElement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SVGTextElement where
-  toJSVal = return . unSVGTextElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SVGTextElement where
-  fromJSVal = return . fmap SVGTextElement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsSVGTextPositioningElement SVGTextElement
-instance IsSVGTextContentElement SVGTextElement
-instance IsSVGGraphicsElement SVGTextElement
-instance IsSVGElement SVGTextElement
-instance IsElement SVGTextElement
-instance IsNode SVGTextElement
-instance IsEventTarget SVGTextElement
-instance IsGObject SVGTextElement where
-  toGObject = GObject . unSVGTextElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SVGTextElement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSVGTextElement :: IsGObject obj => obj -> IO SVGTextElement
-castToSVGTextElement = castTo gTypeSVGTextElement "SVGTextElement"
-
-foreign import javascript unsafe "window[\"SVGTextElement\"]" gTypeSVGTextElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SVGTextPathElement".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.SVGTextContentElement"
---     * "GHCJS.DOM.SVGGraphicsElement"
---     * "GHCJS.DOM.SVGElement"
---     * "GHCJS.DOM.Element"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SVGTextPathElement Mozilla SVGTextPathElement documentation>
-newtype SVGTextPathElement = SVGTextPathElement { unSVGTextPathElement :: JSVal }
-
-instance Eq (SVGTextPathElement) where
-  (SVGTextPathElement a) == (SVGTextPathElement b) = js_eq a b
-
-instance PToJSVal SVGTextPathElement where
-  pToJSVal = unSVGTextPathElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SVGTextPathElement where
-  pFromJSVal = SVGTextPathElement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SVGTextPathElement where
-  toJSVal = return . unSVGTextPathElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SVGTextPathElement where
-  fromJSVal = return . fmap SVGTextPathElement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsSVGTextContentElement SVGTextPathElement
-instance IsSVGGraphicsElement SVGTextPathElement
-instance IsSVGElement SVGTextPathElement
-instance IsElement SVGTextPathElement
-instance IsNode SVGTextPathElement
-instance IsEventTarget SVGTextPathElement
-instance IsGObject SVGTextPathElement where
-  toGObject = GObject . unSVGTextPathElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SVGTextPathElement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSVGTextPathElement :: IsGObject obj => obj -> IO SVGTextPathElement
-castToSVGTextPathElement = castTo gTypeSVGTextPathElement "SVGTextPathElement"
-
-foreign import javascript unsafe "window[\"SVGTextPathElement\"]" gTypeSVGTextPathElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SVGTextPositioningElement".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.SVGTextContentElement"
---     * "GHCJS.DOM.SVGGraphicsElement"
---     * "GHCJS.DOM.SVGElement"
---     * "GHCJS.DOM.Element"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SVGTextPositioningElement Mozilla SVGTextPositioningElement documentation>
-newtype SVGTextPositioningElement = SVGTextPositioningElement { unSVGTextPositioningElement :: JSVal }
-
-instance Eq (SVGTextPositioningElement) where
-  (SVGTextPositioningElement a) == (SVGTextPositioningElement b) = js_eq a b
-
-instance PToJSVal SVGTextPositioningElement where
-  pToJSVal = unSVGTextPositioningElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SVGTextPositioningElement where
-  pFromJSVal = SVGTextPositioningElement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SVGTextPositioningElement where
-  toJSVal = return . unSVGTextPositioningElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SVGTextPositioningElement where
-  fromJSVal = return . fmap SVGTextPositioningElement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-class IsSVGTextContentElement o => IsSVGTextPositioningElement o
-toSVGTextPositioningElement :: IsSVGTextPositioningElement o => o -> SVGTextPositioningElement
-toSVGTextPositioningElement = unsafeCastGObject . toGObject
-
-instance IsSVGTextPositioningElement SVGTextPositioningElement
-instance IsSVGTextContentElement SVGTextPositioningElement
-instance IsSVGGraphicsElement SVGTextPositioningElement
-instance IsSVGElement SVGTextPositioningElement
-instance IsElement SVGTextPositioningElement
-instance IsNode SVGTextPositioningElement
-instance IsEventTarget SVGTextPositioningElement
-instance IsGObject SVGTextPositioningElement where
-  toGObject = GObject . unSVGTextPositioningElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SVGTextPositioningElement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSVGTextPositioningElement :: IsGObject obj => obj -> IO SVGTextPositioningElement
-castToSVGTextPositioningElement = castTo gTypeSVGTextPositioningElement "SVGTextPositioningElement"
-
-foreign import javascript unsafe "window[\"SVGTextPositioningElement\"]" gTypeSVGTextPositioningElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SVGTitleElement".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.SVGElement"
---     * "GHCJS.DOM.Element"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SVGTitleElement Mozilla SVGTitleElement documentation>
-newtype SVGTitleElement = SVGTitleElement { unSVGTitleElement :: JSVal }
-
-instance Eq (SVGTitleElement) where
-  (SVGTitleElement a) == (SVGTitleElement b) = js_eq a b
-
-instance PToJSVal SVGTitleElement where
-  pToJSVal = unSVGTitleElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SVGTitleElement where
-  pFromJSVal = SVGTitleElement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SVGTitleElement where
-  toJSVal = return . unSVGTitleElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SVGTitleElement where
-  fromJSVal = return . fmap SVGTitleElement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsSVGElement SVGTitleElement
-instance IsElement SVGTitleElement
-instance IsNode SVGTitleElement
-instance IsEventTarget SVGTitleElement
-instance IsGObject SVGTitleElement where
-  toGObject = GObject . unSVGTitleElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SVGTitleElement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSVGTitleElement :: IsGObject obj => obj -> IO SVGTitleElement
-castToSVGTitleElement = castTo gTypeSVGTitleElement "SVGTitleElement"
-
-foreign import javascript unsafe "window[\"SVGTitleElement\"]" gTypeSVGTitleElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SVGTransform".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SVGTransform Mozilla SVGTransform documentation>
-newtype SVGTransform = SVGTransform { unSVGTransform :: JSVal }
-
-instance Eq (SVGTransform) where
-  (SVGTransform a) == (SVGTransform b) = js_eq a b
-
-instance PToJSVal SVGTransform where
-  pToJSVal = unSVGTransform
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SVGTransform where
-  pFromJSVal = SVGTransform
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SVGTransform where
-  toJSVal = return . unSVGTransform
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SVGTransform where
-  fromJSVal = return . fmap SVGTransform . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject SVGTransform where
-  toGObject = GObject . unSVGTransform
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SVGTransform . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSVGTransform :: IsGObject obj => obj -> IO SVGTransform
-castToSVGTransform = castTo gTypeSVGTransform "SVGTransform"
-
-foreign import javascript unsafe "window[\"SVGTransform\"]" gTypeSVGTransform :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SVGTransformList".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SVGTransformList Mozilla SVGTransformList documentation>
-newtype SVGTransformList = SVGTransformList { unSVGTransformList :: JSVal }
-
-instance Eq (SVGTransformList) where
-  (SVGTransformList a) == (SVGTransformList b) = js_eq a b
-
-instance PToJSVal SVGTransformList where
-  pToJSVal = unSVGTransformList
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SVGTransformList where
-  pFromJSVal = SVGTransformList
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SVGTransformList where
-  toJSVal = return . unSVGTransformList
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SVGTransformList where
-  fromJSVal = return . fmap SVGTransformList . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject SVGTransformList where
-  toGObject = GObject . unSVGTransformList
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SVGTransformList . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSVGTransformList :: IsGObject obj => obj -> IO SVGTransformList
-castToSVGTransformList = castTo gTypeSVGTransformList "SVGTransformList"
-
-foreign import javascript unsafe "window[\"SVGTransformList\"]" gTypeSVGTransformList :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SVGURIReference".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SVGURIReference Mozilla SVGURIReference documentation>
-newtype SVGURIReference = SVGURIReference { unSVGURIReference :: JSVal }
-
-instance Eq (SVGURIReference) where
-  (SVGURIReference a) == (SVGURIReference b) = js_eq a b
-
-instance PToJSVal SVGURIReference where
-  pToJSVal = unSVGURIReference
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SVGURIReference where
-  pFromJSVal = SVGURIReference
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SVGURIReference where
-  toJSVal = return . unSVGURIReference
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SVGURIReference where
-  fromJSVal = return . fmap SVGURIReference . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject SVGURIReference where
-  toGObject = GObject . unSVGURIReference
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SVGURIReference . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSVGURIReference :: IsGObject obj => obj -> IO SVGURIReference
-castToSVGURIReference = castTo gTypeSVGURIReference "SVGURIReference"
-
-foreign import javascript unsafe "window[\"SVGURIReference\"]" gTypeSVGURIReference :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SVGUnitTypes".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SVGUnitTypes Mozilla SVGUnitTypes documentation>
-newtype SVGUnitTypes = SVGUnitTypes { unSVGUnitTypes :: JSVal }
-
-instance Eq (SVGUnitTypes) where
-  (SVGUnitTypes a) == (SVGUnitTypes b) = js_eq a b
-
-instance PToJSVal SVGUnitTypes where
-  pToJSVal = unSVGUnitTypes
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SVGUnitTypes where
-  pFromJSVal = SVGUnitTypes
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SVGUnitTypes where
-  toJSVal = return . unSVGUnitTypes
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SVGUnitTypes where
-  fromJSVal = return . fmap SVGUnitTypes . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject SVGUnitTypes where
-  toGObject = GObject . unSVGUnitTypes
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SVGUnitTypes . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSVGUnitTypes :: IsGObject obj => obj -> IO SVGUnitTypes
-castToSVGUnitTypes = castTo gTypeSVGUnitTypes "SVGUnitTypes"
-
-foreign import javascript unsafe "window[\"SVGUnitTypes\"]" gTypeSVGUnitTypes :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SVGUseElement".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.SVGGraphicsElement"
---     * "GHCJS.DOM.SVGElement"
---     * "GHCJS.DOM.Element"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SVGUseElement Mozilla SVGUseElement documentation>
-newtype SVGUseElement = SVGUseElement { unSVGUseElement :: JSVal }
-
-instance Eq (SVGUseElement) where
-  (SVGUseElement a) == (SVGUseElement b) = js_eq a b
-
-instance PToJSVal SVGUseElement where
-  pToJSVal = unSVGUseElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SVGUseElement where
-  pFromJSVal = SVGUseElement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SVGUseElement where
-  toJSVal = return . unSVGUseElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SVGUseElement where
-  fromJSVal = return . fmap SVGUseElement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsSVGGraphicsElement SVGUseElement
-instance IsSVGElement SVGUseElement
-instance IsElement SVGUseElement
-instance IsNode SVGUseElement
-instance IsEventTarget SVGUseElement
-instance IsGObject SVGUseElement where
-  toGObject = GObject . unSVGUseElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SVGUseElement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSVGUseElement :: IsGObject obj => obj -> IO SVGUseElement
-castToSVGUseElement = castTo gTypeSVGUseElement "SVGUseElement"
-
-foreign import javascript unsafe "window[\"SVGUseElement\"]" gTypeSVGUseElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SVGVKernElement".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.SVGElement"
---     * "GHCJS.DOM.Element"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SVGVKernElement Mozilla SVGVKernElement documentation>
-newtype SVGVKernElement = SVGVKernElement { unSVGVKernElement :: JSVal }
-
-instance Eq (SVGVKernElement) where
-  (SVGVKernElement a) == (SVGVKernElement b) = js_eq a b
-
-instance PToJSVal SVGVKernElement where
-  pToJSVal = unSVGVKernElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SVGVKernElement where
-  pFromJSVal = SVGVKernElement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SVGVKernElement where
-  toJSVal = return . unSVGVKernElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SVGVKernElement where
-  fromJSVal = return . fmap SVGVKernElement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsSVGElement SVGVKernElement
-instance IsElement SVGVKernElement
-instance IsNode SVGVKernElement
-instance IsEventTarget SVGVKernElement
-instance IsGObject SVGVKernElement where
-  toGObject = GObject . unSVGVKernElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SVGVKernElement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSVGVKernElement :: IsGObject obj => obj -> IO SVGVKernElement
-castToSVGVKernElement = castTo gTypeSVGVKernElement "SVGVKernElement"
-
-foreign import javascript unsafe "window[\"SVGVKernElement\"]" gTypeSVGVKernElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SVGViewElement".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.SVGElement"
---     * "GHCJS.DOM.Element"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SVGViewElement Mozilla SVGViewElement documentation>
-newtype SVGViewElement = SVGViewElement { unSVGViewElement :: JSVal }
-
-instance Eq (SVGViewElement) where
-  (SVGViewElement a) == (SVGViewElement b) = js_eq a b
-
-instance PToJSVal SVGViewElement where
-  pToJSVal = unSVGViewElement
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SVGViewElement where
-  pFromJSVal = SVGViewElement
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SVGViewElement where
-  toJSVal = return . unSVGViewElement
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SVGViewElement where
-  fromJSVal = return . fmap SVGViewElement . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsSVGElement SVGViewElement
-instance IsElement SVGViewElement
-instance IsNode SVGViewElement
-instance IsEventTarget SVGViewElement
-instance IsGObject SVGViewElement where
-  toGObject = GObject . unSVGViewElement
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SVGViewElement . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSVGViewElement :: IsGObject obj => obj -> IO SVGViewElement
-castToSVGViewElement = castTo gTypeSVGViewElement "SVGViewElement"
-
-foreign import javascript unsafe "window[\"SVGViewElement\"]" gTypeSVGViewElement :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SVGViewSpec".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SVGViewSpec Mozilla SVGViewSpec documentation>
-newtype SVGViewSpec = SVGViewSpec { unSVGViewSpec :: JSVal }
-
-instance Eq (SVGViewSpec) where
-  (SVGViewSpec a) == (SVGViewSpec b) = js_eq a b
-
-instance PToJSVal SVGViewSpec where
-  pToJSVal = unSVGViewSpec
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SVGViewSpec where
-  pFromJSVal = SVGViewSpec
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SVGViewSpec where
-  toJSVal = return . unSVGViewSpec
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SVGViewSpec where
-  fromJSVal = return . fmap SVGViewSpec . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject SVGViewSpec where
-  toGObject = GObject . unSVGViewSpec
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SVGViewSpec . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSVGViewSpec :: IsGObject obj => obj -> IO SVGViewSpec
-castToSVGViewSpec = castTo gTypeSVGViewSpec "SVGViewSpec"
-
-foreign import javascript unsafe "window[\"SVGViewSpec\"]" gTypeSVGViewSpec :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SVGZoomAndPan".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SVGZoomAndPan Mozilla SVGZoomAndPan documentation>
-newtype SVGZoomAndPan = SVGZoomAndPan { unSVGZoomAndPan :: JSVal }
-
-instance Eq (SVGZoomAndPan) where
-  (SVGZoomAndPan a) == (SVGZoomAndPan b) = js_eq a b
-
-instance PToJSVal SVGZoomAndPan where
-  pToJSVal = unSVGZoomAndPan
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SVGZoomAndPan where
-  pFromJSVal = SVGZoomAndPan
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SVGZoomAndPan where
-  toJSVal = return . unSVGZoomAndPan
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SVGZoomAndPan where
-  fromJSVal = return . fmap SVGZoomAndPan . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject SVGZoomAndPan where
-  toGObject = GObject . unSVGZoomAndPan
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SVGZoomAndPan . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSVGZoomAndPan :: IsGObject obj => obj -> IO SVGZoomAndPan
-castToSVGZoomAndPan = castTo gTypeSVGZoomAndPan "SVGZoomAndPan"
-
-foreign import javascript unsafe "window[\"SVGZoomAndPan\"]" gTypeSVGZoomAndPan :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SVGZoomEvent".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.UIEvent"
---     * "GHCJS.DOM.Event"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SVGZoomEvent Mozilla SVGZoomEvent documentation>
-newtype SVGZoomEvent = SVGZoomEvent { unSVGZoomEvent :: JSVal }
-
-instance Eq (SVGZoomEvent) where
-  (SVGZoomEvent a) == (SVGZoomEvent b) = js_eq a b
-
-instance PToJSVal SVGZoomEvent where
-  pToJSVal = unSVGZoomEvent
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SVGZoomEvent where
-  pFromJSVal = SVGZoomEvent
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SVGZoomEvent where
-  toJSVal = return . unSVGZoomEvent
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SVGZoomEvent where
-  fromJSVal = return . fmap SVGZoomEvent . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsUIEvent SVGZoomEvent
-instance IsEvent SVGZoomEvent
-instance IsGObject SVGZoomEvent where
-  toGObject = GObject . unSVGZoomEvent
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SVGZoomEvent . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSVGZoomEvent :: IsGObject obj => obj -> IO SVGZoomEvent
-castToSVGZoomEvent = castTo gTypeSVGZoomEvent "SVGZoomEvent"
-
-foreign import javascript unsafe "window[\"SVGZoomEvent\"]" gTypeSVGZoomEvent :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.Screen".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/Screen Mozilla Screen documentation>
-newtype Screen = Screen { unScreen :: JSVal }
-
-instance Eq (Screen) where
-  (Screen a) == (Screen b) = js_eq a b
-
-instance PToJSVal Screen where
-  pToJSVal = unScreen
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal Screen where
-  pFromJSVal = Screen
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal Screen where
-  toJSVal = return . unScreen
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal Screen where
-  fromJSVal = return . fmap Screen . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject Screen where
-  toGObject = GObject . unScreen
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = Screen . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToScreen :: IsGObject obj => obj -> IO Screen
-castToScreen = castTo gTypeScreen "Screen"
-
-foreign import javascript unsafe "window[\"Screen\"]" gTypeScreen :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.ScriptProcessorNode".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.AudioNode"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/ScriptProcessorNode Mozilla ScriptProcessorNode documentation>
-newtype ScriptProcessorNode = ScriptProcessorNode { unScriptProcessorNode :: JSVal }
-
-instance Eq (ScriptProcessorNode) where
-  (ScriptProcessorNode a) == (ScriptProcessorNode b) = js_eq a b
-
-instance PToJSVal ScriptProcessorNode where
-  pToJSVal = unScriptProcessorNode
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal ScriptProcessorNode where
-  pFromJSVal = ScriptProcessorNode
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal ScriptProcessorNode where
-  toJSVal = return . unScriptProcessorNode
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal ScriptProcessorNode where
-  fromJSVal = return . fmap ScriptProcessorNode . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsAudioNode ScriptProcessorNode
-instance IsEventTarget ScriptProcessorNode
-instance IsGObject ScriptProcessorNode where
-  toGObject = GObject . unScriptProcessorNode
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = ScriptProcessorNode . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToScriptProcessorNode :: IsGObject obj => obj -> IO ScriptProcessorNode
-castToScriptProcessorNode = castTo gTypeScriptProcessorNode "ScriptProcessorNode"
-
-foreign import javascript unsafe "window[\"ScriptProcessorNode\"]" gTypeScriptProcessorNode :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.ScriptProfile".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/ScriptProfile Mozilla ScriptProfile documentation>
-newtype ScriptProfile = ScriptProfile { unScriptProfile :: JSVal }
-
-instance Eq (ScriptProfile) where
-  (ScriptProfile a) == (ScriptProfile b) = js_eq a b
-
-instance PToJSVal ScriptProfile where
-  pToJSVal = unScriptProfile
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal ScriptProfile where
-  pFromJSVal = ScriptProfile
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal ScriptProfile where
-  toJSVal = return . unScriptProfile
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal ScriptProfile where
-  fromJSVal = return . fmap ScriptProfile . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject ScriptProfile where
-  toGObject = GObject . unScriptProfile
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = ScriptProfile . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToScriptProfile :: IsGObject obj => obj -> IO ScriptProfile
-castToScriptProfile = castTo gTypeScriptProfile "ScriptProfile"
-
-foreign import javascript unsafe "window[\"ScriptProfile\"]" gTypeScriptProfile :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.ScriptProfileNode".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/ScriptProfileNode Mozilla ScriptProfileNode documentation>
-newtype ScriptProfileNode = ScriptProfileNode { unScriptProfileNode :: JSVal }
-
-instance Eq (ScriptProfileNode) where
-  (ScriptProfileNode a) == (ScriptProfileNode b) = js_eq a b
-
-instance PToJSVal ScriptProfileNode where
-  pToJSVal = unScriptProfileNode
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal ScriptProfileNode where
-  pFromJSVal = ScriptProfileNode
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal ScriptProfileNode where
-  toJSVal = return . unScriptProfileNode
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal ScriptProfileNode where
-  fromJSVal = return . fmap ScriptProfileNode . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject ScriptProfileNode where
-  toGObject = GObject . unScriptProfileNode
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = ScriptProfileNode . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToScriptProfileNode :: IsGObject obj => obj -> IO ScriptProfileNode
-castToScriptProfileNode = castTo gTypeScriptProfileNode "ScriptProfileNode"
-
-foreign import javascript unsafe "window[\"ScriptProfileNode\"]" gTypeScriptProfileNode :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SecurityPolicy".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SecurityPolicy Mozilla SecurityPolicy documentation>
-newtype SecurityPolicy = SecurityPolicy { unSecurityPolicy :: JSVal }
-
-instance Eq (SecurityPolicy) where
-  (SecurityPolicy a) == (SecurityPolicy b) = js_eq a b
-
-instance PToJSVal SecurityPolicy where
-  pToJSVal = unSecurityPolicy
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SecurityPolicy where
-  pFromJSVal = SecurityPolicy
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SecurityPolicy where
-  toJSVal = return . unSecurityPolicy
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SecurityPolicy where
-  fromJSVal = return . fmap SecurityPolicy . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject SecurityPolicy where
-  toGObject = GObject . unSecurityPolicy
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SecurityPolicy . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSecurityPolicy :: IsGObject obj => obj -> IO SecurityPolicy
-castToSecurityPolicy = castTo gTypeSecurityPolicy "SecurityPolicy"
-
-foreign import javascript unsafe "window[\"SecurityPolicy\"]" gTypeSecurityPolicy :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SecurityPolicyViolationEvent".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.Event"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SecurityPolicyViolationEvent Mozilla SecurityPolicyViolationEvent documentation>
-newtype SecurityPolicyViolationEvent = SecurityPolicyViolationEvent { unSecurityPolicyViolationEvent :: JSVal }
-
-instance Eq (SecurityPolicyViolationEvent) where
-  (SecurityPolicyViolationEvent a) == (SecurityPolicyViolationEvent b) = js_eq a b
-
-instance PToJSVal SecurityPolicyViolationEvent where
-  pToJSVal = unSecurityPolicyViolationEvent
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SecurityPolicyViolationEvent where
-  pFromJSVal = SecurityPolicyViolationEvent
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SecurityPolicyViolationEvent where
-  toJSVal = return . unSecurityPolicyViolationEvent
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SecurityPolicyViolationEvent where
-  fromJSVal = return . fmap SecurityPolicyViolationEvent . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsEvent SecurityPolicyViolationEvent
-instance IsGObject SecurityPolicyViolationEvent where
-  toGObject = GObject . unSecurityPolicyViolationEvent
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SecurityPolicyViolationEvent . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSecurityPolicyViolationEvent :: IsGObject obj => obj -> IO SecurityPolicyViolationEvent
-castToSecurityPolicyViolationEvent = castTo gTypeSecurityPolicyViolationEvent "SecurityPolicyViolationEvent"
-
-foreign import javascript unsafe "window[\"SecurityPolicyViolationEvent\"]" gTypeSecurityPolicyViolationEvent :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.Selection".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/Selection Mozilla Selection documentation>
-newtype Selection = Selection { unSelection :: JSVal }
-
-instance Eq (Selection) where
-  (Selection a) == (Selection b) = js_eq a b
-
-instance PToJSVal Selection where
-  pToJSVal = unSelection
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal Selection where
-  pFromJSVal = Selection
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal Selection where
-  toJSVal = return . unSelection
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal Selection where
-  fromJSVal = return . fmap Selection . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject Selection where
-  toGObject = GObject . unSelection
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = Selection . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSelection :: IsGObject obj => obj -> IO Selection
-castToSelection = castTo gTypeSelection "Selection"
-
-foreign import javascript unsafe "window[\"Selection\"]" gTypeSelection :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SourceBuffer".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SourceBuffer Mozilla SourceBuffer documentation>
-newtype SourceBuffer = SourceBuffer { unSourceBuffer :: JSVal }
-
-instance Eq (SourceBuffer) where
-  (SourceBuffer a) == (SourceBuffer b) = js_eq a b
-
-instance PToJSVal SourceBuffer where
-  pToJSVal = unSourceBuffer
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SourceBuffer where
-  pFromJSVal = SourceBuffer
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SourceBuffer where
-  toJSVal = return . unSourceBuffer
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SourceBuffer where
-  fromJSVal = return . fmap SourceBuffer . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsEventTarget SourceBuffer
-instance IsGObject SourceBuffer where
-  toGObject = GObject . unSourceBuffer
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SourceBuffer . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSourceBuffer :: IsGObject obj => obj -> IO SourceBuffer
-castToSourceBuffer = castTo gTypeSourceBuffer "SourceBuffer"
-
-foreign import javascript unsafe "window[\"SourceBuffer\"]" gTypeSourceBuffer :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SourceBufferList".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SourceBufferList Mozilla SourceBufferList documentation>
-newtype SourceBufferList = SourceBufferList { unSourceBufferList :: JSVal }
-
-instance Eq (SourceBufferList) where
-  (SourceBufferList a) == (SourceBufferList b) = js_eq a b
-
-instance PToJSVal SourceBufferList where
-  pToJSVal = unSourceBufferList
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SourceBufferList where
-  pFromJSVal = SourceBufferList
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SourceBufferList where
-  toJSVal = return . unSourceBufferList
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SourceBufferList where
-  fromJSVal = return . fmap SourceBufferList . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsEventTarget SourceBufferList
-instance IsGObject SourceBufferList where
-  toGObject = GObject . unSourceBufferList
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SourceBufferList . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSourceBufferList :: IsGObject obj => obj -> IO SourceBufferList
-castToSourceBufferList = castTo gTypeSourceBufferList "SourceBufferList"
-
-foreign import javascript unsafe "window[\"SourceBufferList\"]" gTypeSourceBufferList :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SourceInfo".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SourceInfo Mozilla SourceInfo documentation>
-newtype SourceInfo = SourceInfo { unSourceInfo :: JSVal }
-
-instance Eq (SourceInfo) where
-  (SourceInfo a) == (SourceInfo b) = js_eq a b
-
-instance PToJSVal SourceInfo where
-  pToJSVal = unSourceInfo
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SourceInfo where
-  pFromJSVal = SourceInfo
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SourceInfo where
-  toJSVal = return . unSourceInfo
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SourceInfo where
-  fromJSVal = return . fmap SourceInfo . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject SourceInfo where
-  toGObject = GObject . unSourceInfo
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SourceInfo . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSourceInfo :: IsGObject obj => obj -> IO SourceInfo
-castToSourceInfo = castTo gTypeSourceInfo "SourceInfo"
-
-foreign import javascript unsafe "window[\"SourceInfo\"]" gTypeSourceInfo :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SpeechSynthesis".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SpeechSynthesis Mozilla SpeechSynthesis documentation>
-newtype SpeechSynthesis = SpeechSynthesis { unSpeechSynthesis :: JSVal }
-
-instance Eq (SpeechSynthesis) where
-  (SpeechSynthesis a) == (SpeechSynthesis b) = js_eq a b
-
-instance PToJSVal SpeechSynthesis where
-  pToJSVal = unSpeechSynthesis
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SpeechSynthesis where
-  pFromJSVal = SpeechSynthesis
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SpeechSynthesis where
-  toJSVal = return . unSpeechSynthesis
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SpeechSynthesis where
-  fromJSVal = return . fmap SpeechSynthesis . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject SpeechSynthesis where
-  toGObject = GObject . unSpeechSynthesis
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SpeechSynthesis . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSpeechSynthesis :: IsGObject obj => obj -> IO SpeechSynthesis
-castToSpeechSynthesis = castTo gTypeSpeechSynthesis "SpeechSynthesis"
-
-foreign import javascript unsafe "window[\"SpeechSynthesis\"]" gTypeSpeechSynthesis :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SpeechSynthesisEvent".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.Event"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SpeechSynthesisEvent Mozilla SpeechSynthesisEvent documentation>
-newtype SpeechSynthesisEvent = SpeechSynthesisEvent { unSpeechSynthesisEvent :: JSVal }
-
-instance Eq (SpeechSynthesisEvent) where
-  (SpeechSynthesisEvent a) == (SpeechSynthesisEvent b) = js_eq a b
-
-instance PToJSVal SpeechSynthesisEvent where
-  pToJSVal = unSpeechSynthesisEvent
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SpeechSynthesisEvent where
-  pFromJSVal = SpeechSynthesisEvent
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SpeechSynthesisEvent where
-  toJSVal = return . unSpeechSynthesisEvent
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SpeechSynthesisEvent where
-  fromJSVal = return . fmap SpeechSynthesisEvent . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsEvent SpeechSynthesisEvent
-instance IsGObject SpeechSynthesisEvent where
-  toGObject = GObject . unSpeechSynthesisEvent
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SpeechSynthesisEvent . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSpeechSynthesisEvent :: IsGObject obj => obj -> IO SpeechSynthesisEvent
-castToSpeechSynthesisEvent = castTo gTypeSpeechSynthesisEvent "SpeechSynthesisEvent"
-
-foreign import javascript unsafe "window[\"SpeechSynthesisEvent\"]" gTypeSpeechSynthesisEvent :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SpeechSynthesisUtterance".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SpeechSynthesisUtterance Mozilla SpeechSynthesisUtterance documentation>
-newtype SpeechSynthesisUtterance = SpeechSynthesisUtterance { unSpeechSynthesisUtterance :: JSVal }
-
-instance Eq (SpeechSynthesisUtterance) where
-  (SpeechSynthesisUtterance a) == (SpeechSynthesisUtterance b) = js_eq a b
-
-instance PToJSVal SpeechSynthesisUtterance where
-  pToJSVal = unSpeechSynthesisUtterance
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SpeechSynthesisUtterance where
-  pFromJSVal = SpeechSynthesisUtterance
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SpeechSynthesisUtterance where
-  toJSVal = return . unSpeechSynthesisUtterance
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SpeechSynthesisUtterance where
-  fromJSVal = return . fmap SpeechSynthesisUtterance . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsEventTarget SpeechSynthesisUtterance
-instance IsGObject SpeechSynthesisUtterance where
-  toGObject = GObject . unSpeechSynthesisUtterance
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SpeechSynthesisUtterance . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSpeechSynthesisUtterance :: IsGObject obj => obj -> IO SpeechSynthesisUtterance
-castToSpeechSynthesisUtterance = castTo gTypeSpeechSynthesisUtterance "SpeechSynthesisUtterance"
-
-foreign import javascript unsafe "window[\"SpeechSynthesisUtterance\"]" gTypeSpeechSynthesisUtterance :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SpeechSynthesisVoice".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/SpeechSynthesisVoice Mozilla SpeechSynthesisVoice documentation>
-newtype SpeechSynthesisVoice = SpeechSynthesisVoice { unSpeechSynthesisVoice :: JSVal }
-
-instance Eq (SpeechSynthesisVoice) where
-  (SpeechSynthesisVoice a) == (SpeechSynthesisVoice b) = js_eq a b
-
-instance PToJSVal SpeechSynthesisVoice where
-  pToJSVal = unSpeechSynthesisVoice
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SpeechSynthesisVoice where
-  pFromJSVal = SpeechSynthesisVoice
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SpeechSynthesisVoice where
-  toJSVal = return . unSpeechSynthesisVoice
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SpeechSynthesisVoice where
-  fromJSVal = return . fmap SpeechSynthesisVoice . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject SpeechSynthesisVoice where
-  toGObject = GObject . unSpeechSynthesisVoice
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SpeechSynthesisVoice . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSpeechSynthesisVoice :: IsGObject obj => obj -> IO SpeechSynthesisVoice
-castToSpeechSynthesisVoice = castTo gTypeSpeechSynthesisVoice "SpeechSynthesisVoice"
-
-foreign import javascript unsafe "window[\"SpeechSynthesisVoice\"]" gTypeSpeechSynthesisVoice :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.Storage".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/Storage Mozilla Storage documentation>
-newtype Storage = Storage { unStorage :: JSVal }
-
-instance Eq (Storage) where
-  (Storage a) == (Storage b) = js_eq a b
-
-instance PToJSVal Storage where
-  pToJSVal = unStorage
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal Storage where
-  pFromJSVal = Storage
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal Storage where
-  toJSVal = return . unStorage
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal Storage where
-  fromJSVal = return . fmap Storage . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject Storage where
-  toGObject = GObject . unStorage
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = Storage . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToStorage :: IsGObject obj => obj -> IO Storage
-castToStorage = castTo gTypeStorage "Storage"
-
-foreign import javascript unsafe "window[\"Storage\"]" gTypeStorage :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.StorageEvent".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.Event"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/StorageEvent Mozilla StorageEvent documentation>
-newtype StorageEvent = StorageEvent { unStorageEvent :: JSVal }
-
-instance Eq (StorageEvent) where
-  (StorageEvent a) == (StorageEvent b) = js_eq a b
-
-instance PToJSVal StorageEvent where
-  pToJSVal = unStorageEvent
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal StorageEvent where
-  pFromJSVal = StorageEvent
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal StorageEvent where
-  toJSVal = return . unStorageEvent
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal StorageEvent where
-  fromJSVal = return . fmap StorageEvent . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsEvent StorageEvent
-instance IsGObject StorageEvent where
-  toGObject = GObject . unStorageEvent
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = StorageEvent . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToStorageEvent :: IsGObject obj => obj -> IO StorageEvent
-castToStorageEvent = castTo gTypeStorageEvent "StorageEvent"
-
-foreign import javascript unsafe "window[\"StorageEvent\"]" gTypeStorageEvent :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.StorageInfo".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/StorageInfo Mozilla StorageInfo documentation>
-newtype StorageInfo = StorageInfo { unStorageInfo :: JSVal }
-
-instance Eq (StorageInfo) where
-  (StorageInfo a) == (StorageInfo b) = js_eq a b
-
-instance PToJSVal StorageInfo where
-  pToJSVal = unStorageInfo
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal StorageInfo where
-  pFromJSVal = StorageInfo
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal StorageInfo where
-  toJSVal = return . unStorageInfo
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal StorageInfo where
-  fromJSVal = return . fmap StorageInfo . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject StorageInfo where
-  toGObject = GObject . unStorageInfo
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = StorageInfo . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToStorageInfo :: IsGObject obj => obj -> IO StorageInfo
-castToStorageInfo = castTo gTypeStorageInfo "StorageInfo"
-
-foreign import javascript unsafe "window[\"StorageInfo\"]" gTypeStorageInfo :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.StorageQuota".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/StorageQuota Mozilla StorageQuota documentation>
-newtype StorageQuota = StorageQuota { unStorageQuota :: JSVal }
-
-instance Eq (StorageQuota) where
-  (StorageQuota a) == (StorageQuota b) = js_eq a b
-
-instance PToJSVal StorageQuota where
-  pToJSVal = unStorageQuota
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal StorageQuota where
-  pFromJSVal = StorageQuota
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal StorageQuota where
-  toJSVal = return . unStorageQuota
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal StorageQuota where
-  fromJSVal = return . fmap StorageQuota . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject StorageQuota where
-  toGObject = GObject . unStorageQuota
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = StorageQuota . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToStorageQuota :: IsGObject obj => obj -> IO StorageQuota
-castToStorageQuota = castTo gTypeStorageQuota "StorageQuota"
-
-foreign import javascript unsafe "window[\"StorageQuota\"]" gTypeStorageQuota :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.StyleMedia".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/StyleMedia Mozilla StyleMedia documentation>
-newtype StyleMedia = StyleMedia { unStyleMedia :: JSVal }
-
-instance Eq (StyleMedia) where
-  (StyleMedia a) == (StyleMedia b) = js_eq a b
-
-instance PToJSVal StyleMedia where
-  pToJSVal = unStyleMedia
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal StyleMedia where
-  pFromJSVal = StyleMedia
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal StyleMedia where
-  toJSVal = return . unStyleMedia
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal StyleMedia where
-  fromJSVal = return . fmap StyleMedia . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject StyleMedia where
-  toGObject = GObject . unStyleMedia
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = StyleMedia . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToStyleMedia :: IsGObject obj => obj -> IO StyleMedia
-castToStyleMedia = castTo gTypeStyleMedia "StyleMedia"
-
-foreign import javascript unsafe "window[\"StyleMedia\"]" gTypeStyleMedia :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.StyleSheet".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/StyleSheet Mozilla StyleSheet documentation>
-newtype StyleSheet = StyleSheet { unStyleSheet :: JSVal }
-
-instance Eq (StyleSheet) where
-  (StyleSheet a) == (StyleSheet b) = js_eq a b
-
-instance PToJSVal StyleSheet where
-  pToJSVal = unStyleSheet
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal StyleSheet where
-  pFromJSVal = StyleSheet
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal StyleSheet where
-  toJSVal = return . unStyleSheet
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal StyleSheet where
-  fromJSVal = return . fmap StyleSheet . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-class IsGObject o => IsStyleSheet o
-toStyleSheet :: IsStyleSheet o => o -> StyleSheet
-toStyleSheet = unsafeCastGObject . toGObject
-
-instance IsStyleSheet StyleSheet
-instance IsGObject StyleSheet where
-  toGObject = GObject . unStyleSheet
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = StyleSheet . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToStyleSheet :: IsGObject obj => obj -> IO StyleSheet
-castToStyleSheet = castTo gTypeStyleSheet "StyleSheet"
-
-foreign import javascript unsafe "window[\"StyleSheet\"]" gTypeStyleSheet :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.StyleSheetList".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/StyleSheetList Mozilla StyleSheetList documentation>
-newtype StyleSheetList = StyleSheetList { unStyleSheetList :: JSVal }
-
-instance Eq (StyleSheetList) where
-  (StyleSheetList a) == (StyleSheetList b) = js_eq a b
-
-instance PToJSVal StyleSheetList where
-  pToJSVal = unStyleSheetList
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal StyleSheetList where
-  pFromJSVal = StyleSheetList
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal StyleSheetList where
-  toJSVal = return . unStyleSheetList
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal StyleSheetList where
-  fromJSVal = return . fmap StyleSheetList . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject StyleSheetList where
-  toGObject = GObject . unStyleSheetList
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = StyleSheetList . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToStyleSheetList :: IsGObject obj => obj -> IO StyleSheetList
-castToStyleSheetList = castTo gTypeStyleSheetList "StyleSheetList"
-
-foreign import javascript unsafe "window[\"StyleSheetList\"]" gTypeStyleSheetList :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.SubtleCrypto".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/WebKitSubtleCrypto Mozilla WebKitSubtleCrypto documentation>
-newtype SubtleCrypto = SubtleCrypto { unSubtleCrypto :: JSVal }
-
-instance Eq (SubtleCrypto) where
-  (SubtleCrypto a) == (SubtleCrypto b) = js_eq a b
-
-instance PToJSVal SubtleCrypto where
-  pToJSVal = unSubtleCrypto
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal SubtleCrypto where
-  pFromJSVal = SubtleCrypto
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal SubtleCrypto where
-  toJSVal = return . unSubtleCrypto
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal SubtleCrypto where
-  fromJSVal = return . fmap SubtleCrypto . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject SubtleCrypto where
-  toGObject = GObject . unSubtleCrypto
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = SubtleCrypto . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToSubtleCrypto :: IsGObject obj => obj -> IO SubtleCrypto
-castToSubtleCrypto = castTo gTypeSubtleCrypto "SubtleCrypto"
-
-foreign import javascript unsafe "window[\"WebKitSubtleCrypto\"]" gTypeSubtleCrypto :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.Text".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.CharacterData"
---     * "GHCJS.DOM.Node"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/Text Mozilla Text documentation>
-newtype Text = Text { unText :: JSVal }
-
-instance Eq (Text) where
-  (Text a) == (Text b) = js_eq a b
-
-instance PToJSVal Text where
-  pToJSVal = unText
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal Text where
-  pFromJSVal = Text
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal Text where
-  toJSVal = return . unText
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal Text where
-  fromJSVal = return . fmap Text . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-class IsCharacterData o => IsText o
-toText :: IsText o => o -> Text
-toText = unsafeCastGObject . toGObject
-
-instance IsText Text
-instance IsCharacterData Text
-instance IsNode Text
-instance IsEventTarget Text
-instance IsGObject Text where
-  toGObject = GObject . unText
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = Text . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToText :: IsGObject obj => obj -> IO Text
-castToText = castTo gTypeText "Text"
-
-foreign import javascript unsafe "window[\"Text\"]" gTypeText :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.TextEvent".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.UIEvent"
---     * "GHCJS.DOM.Event"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/TextEvent Mozilla TextEvent documentation>
-newtype TextEvent = TextEvent { unTextEvent :: JSVal }
-
-instance Eq (TextEvent) where
-  (TextEvent a) == (TextEvent b) = js_eq a b
-
-instance PToJSVal TextEvent where
-  pToJSVal = unTextEvent
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal TextEvent where
-  pFromJSVal = TextEvent
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal TextEvent where
-  toJSVal = return . unTextEvent
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal TextEvent where
-  fromJSVal = return . fmap TextEvent . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsUIEvent TextEvent
-instance IsEvent TextEvent
-instance IsGObject TextEvent where
-  toGObject = GObject . unTextEvent
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = TextEvent . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToTextEvent :: IsGObject obj => obj -> IO TextEvent
-castToTextEvent = castTo gTypeTextEvent "TextEvent"
-
-foreign import javascript unsafe "window[\"TextEvent\"]" gTypeTextEvent :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.TextMetrics".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/TextMetrics Mozilla TextMetrics documentation>
-newtype TextMetrics = TextMetrics { unTextMetrics :: JSVal }
-
-instance Eq (TextMetrics) where
-  (TextMetrics a) == (TextMetrics b) = js_eq a b
-
-instance PToJSVal TextMetrics where
-  pToJSVal = unTextMetrics
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal TextMetrics where
-  pFromJSVal = TextMetrics
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal TextMetrics where
-  toJSVal = return . unTextMetrics
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal TextMetrics where
-  fromJSVal = return . fmap TextMetrics . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject TextMetrics where
-  toGObject = GObject . unTextMetrics
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = TextMetrics . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToTextMetrics :: IsGObject obj => obj -> IO TextMetrics
-castToTextMetrics = castTo gTypeTextMetrics "TextMetrics"
-
-foreign import javascript unsafe "window[\"TextMetrics\"]" gTypeTextMetrics :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.TextTrack".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/TextTrack Mozilla TextTrack documentation>
-newtype TextTrack = TextTrack { unTextTrack :: JSVal }
-
-instance Eq (TextTrack) where
-  (TextTrack a) == (TextTrack b) = js_eq a b
-
-instance PToJSVal TextTrack where
-  pToJSVal = unTextTrack
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal TextTrack where
-  pFromJSVal = TextTrack
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal TextTrack where
-  toJSVal = return . unTextTrack
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal TextTrack where
-  fromJSVal = return . fmap TextTrack . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsEventTarget TextTrack
-instance IsGObject TextTrack where
-  toGObject = GObject . unTextTrack
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = TextTrack . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToTextTrack :: IsGObject obj => obj -> IO TextTrack
-castToTextTrack = castTo gTypeTextTrack "TextTrack"
-
-foreign import javascript unsafe "window[\"TextTrack\"]" gTypeTextTrack :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.TextTrackCue".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/TextTrackCue Mozilla TextTrackCue documentation>
-newtype TextTrackCue = TextTrackCue { unTextTrackCue :: JSVal }
-
-instance Eq (TextTrackCue) where
-  (TextTrackCue a) == (TextTrackCue b) = js_eq a b
-
-instance PToJSVal TextTrackCue where
-  pToJSVal = unTextTrackCue
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal TextTrackCue where
-  pFromJSVal = TextTrackCue
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal TextTrackCue where
-  toJSVal = return . unTextTrackCue
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal TextTrackCue where
-  fromJSVal = return . fmap TextTrackCue . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-class IsEventTarget o => IsTextTrackCue o
-toTextTrackCue :: IsTextTrackCue o => o -> TextTrackCue
-toTextTrackCue = unsafeCastGObject . toGObject
-
-instance IsTextTrackCue TextTrackCue
-instance IsEventTarget TextTrackCue
-instance IsGObject TextTrackCue where
-  toGObject = GObject . unTextTrackCue
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = TextTrackCue . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToTextTrackCue :: IsGObject obj => obj -> IO TextTrackCue
-castToTextTrackCue = castTo gTypeTextTrackCue "TextTrackCue"
-
-foreign import javascript unsafe "window[\"TextTrackCue\"]" gTypeTextTrackCue :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.TextTrackCueList".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/TextTrackCueList Mozilla TextTrackCueList documentation>
-newtype TextTrackCueList = TextTrackCueList { unTextTrackCueList :: JSVal }
-
-instance Eq (TextTrackCueList) where
-  (TextTrackCueList a) == (TextTrackCueList b) = js_eq a b
-
-instance PToJSVal TextTrackCueList where
-  pToJSVal = unTextTrackCueList
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal TextTrackCueList where
-  pFromJSVal = TextTrackCueList
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal TextTrackCueList where
-  toJSVal = return . unTextTrackCueList
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal TextTrackCueList where
-  fromJSVal = return . fmap TextTrackCueList . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject TextTrackCueList where
-  toGObject = GObject . unTextTrackCueList
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = TextTrackCueList . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToTextTrackCueList :: IsGObject obj => obj -> IO TextTrackCueList
-castToTextTrackCueList = castTo gTypeTextTrackCueList "TextTrackCueList"
-
-foreign import javascript unsafe "window[\"TextTrackCueList\"]" gTypeTextTrackCueList :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.TextTrackList".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/TextTrackList Mozilla TextTrackList documentation>
-newtype TextTrackList = TextTrackList { unTextTrackList :: JSVal }
-
-instance Eq (TextTrackList) where
-  (TextTrackList a) == (TextTrackList b) = js_eq a b
-
-instance PToJSVal TextTrackList where
-  pToJSVal = unTextTrackList
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal TextTrackList where
-  pFromJSVal = TextTrackList
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal TextTrackList where
-  toJSVal = return . unTextTrackList
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal TextTrackList where
-  fromJSVal = return . fmap TextTrackList . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsEventTarget TextTrackList
-instance IsGObject TextTrackList where
-  toGObject = GObject . unTextTrackList
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = TextTrackList . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToTextTrackList :: IsGObject obj => obj -> IO TextTrackList
-castToTextTrackList = castTo gTypeTextTrackList "TextTrackList"
-
-foreign import javascript unsafe "window[\"TextTrackList\"]" gTypeTextTrackList :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.TimeRanges".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/TimeRanges Mozilla TimeRanges documentation>
-newtype TimeRanges = TimeRanges { unTimeRanges :: JSVal }
-
-instance Eq (TimeRanges) where
-  (TimeRanges a) == (TimeRanges b) = js_eq a b
-
-instance PToJSVal TimeRanges where
-  pToJSVal = unTimeRanges
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal TimeRanges where
-  pFromJSVal = TimeRanges
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal TimeRanges where
-  toJSVal = return . unTimeRanges
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal TimeRanges where
-  fromJSVal = return . fmap TimeRanges . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject TimeRanges where
-  toGObject = GObject . unTimeRanges
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = TimeRanges . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToTimeRanges :: IsGObject obj => obj -> IO TimeRanges
-castToTimeRanges = castTo gTypeTimeRanges "TimeRanges"
-
-foreign import javascript unsafe "window[\"TimeRanges\"]" gTypeTimeRanges :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.Touch".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/Touch Mozilla Touch documentation>
-newtype Touch = Touch { unTouch :: JSVal }
-
-instance Eq (Touch) where
-  (Touch a) == (Touch b) = js_eq a b
-
-instance PToJSVal Touch where
-  pToJSVal = unTouch
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal Touch where
-  pFromJSVal = Touch
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal Touch where
-  toJSVal = return . unTouch
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal Touch where
-  fromJSVal = return . fmap Touch . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject Touch where
-  toGObject = GObject . unTouch
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = Touch . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToTouch :: IsGObject obj => obj -> IO Touch
-castToTouch = castTo gTypeTouch "Touch"
-
-foreign import javascript unsafe "window[\"Touch\"]" gTypeTouch :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.TouchEvent".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.UIEvent"
---     * "GHCJS.DOM.Event"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/TouchEvent Mozilla TouchEvent documentation>
-newtype TouchEvent = TouchEvent { unTouchEvent :: JSVal }
-
-instance Eq (TouchEvent) where
-  (TouchEvent a) == (TouchEvent b) = js_eq a b
-
-instance PToJSVal TouchEvent where
-  pToJSVal = unTouchEvent
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal TouchEvent where
-  pFromJSVal = TouchEvent
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal TouchEvent where
-  toJSVal = return . unTouchEvent
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal TouchEvent where
-  fromJSVal = return . fmap TouchEvent . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsUIEvent TouchEvent
-instance IsEvent TouchEvent
-instance IsGObject TouchEvent where
-  toGObject = GObject . unTouchEvent
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = TouchEvent . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToTouchEvent :: IsGObject obj => obj -> IO TouchEvent
-castToTouchEvent = castTo gTypeTouchEvent "TouchEvent"
-
-foreign import javascript unsafe "window[\"TouchEvent\"]" gTypeTouchEvent :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.TouchList".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/TouchList Mozilla TouchList documentation>
-newtype TouchList = TouchList { unTouchList :: JSVal }
-
-instance Eq (TouchList) where
-  (TouchList a) == (TouchList b) = js_eq a b
-
-instance PToJSVal TouchList where
-  pToJSVal = unTouchList
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal TouchList where
-  pFromJSVal = TouchList
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal TouchList where
-  toJSVal = return . unTouchList
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal TouchList where
-  fromJSVal = return . fmap TouchList . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject TouchList where
-  toGObject = GObject . unTouchList
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = TouchList . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToTouchList :: IsGObject obj => obj -> IO TouchList
-castToTouchList = castTo gTypeTouchList "TouchList"
-
-foreign import javascript unsafe "window[\"TouchList\"]" gTypeTouchList :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.TrackEvent".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.Event"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/TrackEvent Mozilla TrackEvent documentation>
-newtype TrackEvent = TrackEvent { unTrackEvent :: JSVal }
-
-instance Eq (TrackEvent) where
-  (TrackEvent a) == (TrackEvent b) = js_eq a b
-
-instance PToJSVal TrackEvent where
-  pToJSVal = unTrackEvent
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal TrackEvent where
-  pFromJSVal = TrackEvent
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal TrackEvent where
-  toJSVal = return . unTrackEvent
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal TrackEvent where
-  fromJSVal = return . fmap TrackEvent . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsEvent TrackEvent
-instance IsGObject TrackEvent where
-  toGObject = GObject . unTrackEvent
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = TrackEvent . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToTrackEvent :: IsGObject obj => obj -> IO TrackEvent
-castToTrackEvent = castTo gTypeTrackEvent "TrackEvent"
-
-foreign import javascript unsafe "window[\"TrackEvent\"]" gTypeTrackEvent :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.TransitionEvent".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.Event"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/TransitionEvent Mozilla TransitionEvent documentation>
-newtype TransitionEvent = TransitionEvent { unTransitionEvent :: JSVal }
-
-instance Eq (TransitionEvent) where
-  (TransitionEvent a) == (TransitionEvent b) = js_eq a b
-
-instance PToJSVal TransitionEvent where
-  pToJSVal = unTransitionEvent
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal TransitionEvent where
-  pFromJSVal = TransitionEvent
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal TransitionEvent where
-  toJSVal = return . unTransitionEvent
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal TransitionEvent where
-  fromJSVal = return . fmap TransitionEvent . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsEvent TransitionEvent
-instance IsGObject TransitionEvent where
-  toGObject = GObject . unTransitionEvent
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = TransitionEvent . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToTransitionEvent :: IsGObject obj => obj -> IO TransitionEvent
-castToTransitionEvent = castTo gTypeTransitionEvent "TransitionEvent"
-
-foreign import javascript unsafe "window[\"TransitionEvent\"]" gTypeTransitionEvent :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.TreeWalker".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/TreeWalker Mozilla TreeWalker documentation>
-newtype TreeWalker = TreeWalker { unTreeWalker :: JSVal }
-
-instance Eq (TreeWalker) where
-  (TreeWalker a) == (TreeWalker b) = js_eq a b
-
-instance PToJSVal TreeWalker where
-  pToJSVal = unTreeWalker
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal TreeWalker where
-  pFromJSVal = TreeWalker
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal TreeWalker where
-  toJSVal = return . unTreeWalker
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal TreeWalker where
-  fromJSVal = return . fmap TreeWalker . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject TreeWalker where
-  toGObject = GObject . unTreeWalker
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = TreeWalker . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToTreeWalker :: IsGObject obj => obj -> IO TreeWalker
-castToTreeWalker = castTo gTypeTreeWalker "TreeWalker"
-
-foreign import javascript unsafe "window[\"TreeWalker\"]" gTypeTreeWalker :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.TypeConversions".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/TypeConversions Mozilla TypeConversions documentation>
-newtype TypeConversions = TypeConversions { unTypeConversions :: JSVal }
-
-instance Eq (TypeConversions) where
-  (TypeConversions a) == (TypeConversions b) = js_eq a b
-
-instance PToJSVal TypeConversions where
-  pToJSVal = unTypeConversions
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal TypeConversions where
-  pFromJSVal = TypeConversions
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal TypeConversions where
-  toJSVal = return . unTypeConversions
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal TypeConversions where
-  fromJSVal = return . fmap TypeConversions . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject TypeConversions where
-  toGObject = GObject . unTypeConversions
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = TypeConversions . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToTypeConversions :: IsGObject obj => obj -> IO TypeConversions
-castToTypeConversions = castTo gTypeTypeConversions "TypeConversions"
-
-foreign import javascript unsafe "window[\"TypeConversions\"]" gTypeTypeConversions :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.UIEvent".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.Event"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/UIEvent Mozilla UIEvent documentation>
-newtype UIEvent = UIEvent { unUIEvent :: JSVal }
-
-instance Eq (UIEvent) where
-  (UIEvent a) == (UIEvent b) = js_eq a b
-
-instance PToJSVal UIEvent where
-  pToJSVal = unUIEvent
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal UIEvent where
-  pFromJSVal = UIEvent
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal UIEvent where
-  toJSVal = return . unUIEvent
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal UIEvent where
-  fromJSVal = return . fmap UIEvent . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-class IsEvent o => IsUIEvent o
-toUIEvent :: IsUIEvent o => o -> UIEvent
-toUIEvent = unsafeCastGObject . toGObject
-
-instance IsUIEvent UIEvent
-instance IsEvent UIEvent
-instance IsGObject UIEvent where
-  toGObject = GObject . unUIEvent
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = UIEvent . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToUIEvent :: IsGObject obj => obj -> IO UIEvent
-castToUIEvent = castTo gTypeUIEvent "UIEvent"
-
-foreign import javascript unsafe "window[\"UIEvent\"]" gTypeUIEvent :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.UIRequestEvent".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.UIEvent"
---     * "GHCJS.DOM.Event"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/UIRequestEvent Mozilla UIRequestEvent documentation>
-newtype UIRequestEvent = UIRequestEvent { unUIRequestEvent :: JSVal }
-
-instance Eq (UIRequestEvent) where
-  (UIRequestEvent a) == (UIRequestEvent b) = js_eq a b
-
-instance PToJSVal UIRequestEvent where
-  pToJSVal = unUIRequestEvent
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal UIRequestEvent where
-  pFromJSVal = UIRequestEvent
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal UIRequestEvent where
-  toJSVal = return . unUIRequestEvent
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal UIRequestEvent where
-  fromJSVal = return . fmap UIRequestEvent . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsUIEvent UIRequestEvent
-instance IsEvent UIRequestEvent
-instance IsGObject UIRequestEvent where
-  toGObject = GObject . unUIRequestEvent
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = UIRequestEvent . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToUIRequestEvent :: IsGObject obj => obj -> IO UIRequestEvent
-castToUIRequestEvent = castTo gTypeUIRequestEvent "UIRequestEvent"
-
-foreign import javascript unsafe "window[\"UIRequestEvent\"]" gTypeUIRequestEvent :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.URL".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/URL Mozilla URL documentation>
-newtype URL = URL { unURL :: JSVal }
-
-instance Eq (URL) where
-  (URL a) == (URL b) = js_eq a b
-
-instance PToJSVal URL where
-  pToJSVal = unURL
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal URL where
-  pFromJSVal = URL
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal URL where
-  toJSVal = return . unURL
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal URL where
-  fromJSVal = return . fmap URL . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject URL where
-  toGObject = GObject . unURL
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = URL . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToURL :: IsGObject obj => obj -> IO URL
-castToURL = castTo gTypeURL "URL"
-
-foreign import javascript unsafe "window[\"URL\"]" gTypeURL :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.URLUtils".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/URLUtils Mozilla URLUtils documentation>
-newtype URLUtils = URLUtils { unURLUtils :: JSVal }
-
-instance Eq (URLUtils) where
-  (URLUtils a) == (URLUtils b) = js_eq a b
-
-instance PToJSVal URLUtils where
-  pToJSVal = unURLUtils
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal URLUtils where
-  pFromJSVal = URLUtils
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal URLUtils where
-  toJSVal = return . unURLUtils
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal URLUtils where
-  fromJSVal = return . fmap URLUtils . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject URLUtils where
-  toGObject = GObject . unURLUtils
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = URLUtils . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToURLUtils :: IsGObject obj => obj -> IO URLUtils
-castToURLUtils = castTo gTypeURLUtils "URLUtils"
-
-foreign import javascript unsafe "window[\"URLUtils\"]" gTypeURLUtils :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.UserMessageHandler".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/UserMessageHandler Mozilla UserMessageHandler documentation>
-newtype UserMessageHandler = UserMessageHandler { unUserMessageHandler :: JSVal }
-
-instance Eq (UserMessageHandler) where
-  (UserMessageHandler a) == (UserMessageHandler b) = js_eq a b
-
-instance PToJSVal UserMessageHandler where
-  pToJSVal = unUserMessageHandler
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal UserMessageHandler where
-  pFromJSVal = UserMessageHandler
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal UserMessageHandler where
-  toJSVal = return . unUserMessageHandler
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal UserMessageHandler where
-  fromJSVal = return . fmap UserMessageHandler . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject UserMessageHandler where
-  toGObject = GObject . unUserMessageHandler
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = UserMessageHandler . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToUserMessageHandler :: IsGObject obj => obj -> IO UserMessageHandler
-castToUserMessageHandler = castTo gTypeUserMessageHandler "UserMessageHandler"
-
-foreign import javascript unsafe "window[\"UserMessageHandler\"]" gTypeUserMessageHandler :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.UserMessageHandlersNamespace".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/UserMessageHandlersNamespace Mozilla UserMessageHandlersNamespace documentation>
-newtype UserMessageHandlersNamespace = UserMessageHandlersNamespace { unUserMessageHandlersNamespace :: JSVal }
-
-instance Eq (UserMessageHandlersNamespace) where
-  (UserMessageHandlersNamespace a) == (UserMessageHandlersNamespace b) = js_eq a b
-
-instance PToJSVal UserMessageHandlersNamespace where
-  pToJSVal = unUserMessageHandlersNamespace
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal UserMessageHandlersNamespace where
-  pFromJSVal = UserMessageHandlersNamespace
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal UserMessageHandlersNamespace where
-  toJSVal = return . unUserMessageHandlersNamespace
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal UserMessageHandlersNamespace where
-  fromJSVal = return . fmap UserMessageHandlersNamespace . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject UserMessageHandlersNamespace where
-  toGObject = GObject . unUserMessageHandlersNamespace
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = UserMessageHandlersNamespace . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToUserMessageHandlersNamespace :: IsGObject obj => obj -> IO UserMessageHandlersNamespace
-castToUserMessageHandlersNamespace = castTo gTypeUserMessageHandlersNamespace "UserMessageHandlersNamespace"
-
-foreign import javascript unsafe "window[\"UserMessageHandlersNamespace\"]" gTypeUserMessageHandlersNamespace :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.VTTCue".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.TextTrackCue"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/VTTCue Mozilla VTTCue documentation>
-newtype VTTCue = VTTCue { unVTTCue :: JSVal }
-
-instance Eq (VTTCue) where
-  (VTTCue a) == (VTTCue b) = js_eq a b
-
-instance PToJSVal VTTCue where
-  pToJSVal = unVTTCue
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal VTTCue where
-  pFromJSVal = VTTCue
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal VTTCue where
-  toJSVal = return . unVTTCue
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal VTTCue where
-  fromJSVal = return . fmap VTTCue . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsTextTrackCue VTTCue
-instance IsEventTarget VTTCue
-instance IsGObject VTTCue where
-  toGObject = GObject . unVTTCue
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = VTTCue . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToVTTCue :: IsGObject obj => obj -> IO VTTCue
-castToVTTCue = castTo gTypeVTTCue "VTTCue"
-
-foreign import javascript unsafe "window[\"VTTCue\"]" gTypeVTTCue :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.VTTRegion".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/VTTRegion Mozilla VTTRegion documentation>
-newtype VTTRegion = VTTRegion { unVTTRegion :: JSVal }
-
-instance Eq (VTTRegion) where
-  (VTTRegion a) == (VTTRegion b) = js_eq a b
-
-instance PToJSVal VTTRegion where
-  pToJSVal = unVTTRegion
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal VTTRegion where
-  pFromJSVal = VTTRegion
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal VTTRegion where
-  toJSVal = return . unVTTRegion
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal VTTRegion where
-  fromJSVal = return . fmap VTTRegion . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject VTTRegion where
-  toGObject = GObject . unVTTRegion
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = VTTRegion . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToVTTRegion :: IsGObject obj => obj -> IO VTTRegion
-castToVTTRegion = castTo gTypeVTTRegion "VTTRegion"
-
-foreign import javascript unsafe "window[\"VTTRegion\"]" gTypeVTTRegion :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.VTTRegionList".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/VTTRegionList Mozilla VTTRegionList documentation>
-newtype VTTRegionList = VTTRegionList { unVTTRegionList :: JSVal }
-
-instance Eq (VTTRegionList) where
-  (VTTRegionList a) == (VTTRegionList b) = js_eq a b
-
-instance PToJSVal VTTRegionList where
-  pToJSVal = unVTTRegionList
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal VTTRegionList where
-  pFromJSVal = VTTRegionList
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal VTTRegionList where
-  toJSVal = return . unVTTRegionList
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal VTTRegionList where
-  fromJSVal = return . fmap VTTRegionList . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject VTTRegionList where
-  toGObject = GObject . unVTTRegionList
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = VTTRegionList . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToVTTRegionList :: IsGObject obj => obj -> IO VTTRegionList
-castToVTTRegionList = castTo gTypeVTTRegionList "VTTRegionList"
-
-foreign import javascript unsafe "window[\"VTTRegionList\"]" gTypeVTTRegionList :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.ValidityState".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/ValidityState Mozilla ValidityState documentation>
-newtype ValidityState = ValidityState { unValidityState :: JSVal }
-
-instance Eq (ValidityState) where
-  (ValidityState a) == (ValidityState b) = js_eq a b
-
-instance PToJSVal ValidityState where
-  pToJSVal = unValidityState
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal ValidityState where
-  pFromJSVal = ValidityState
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal ValidityState where
-  toJSVal = return . unValidityState
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal ValidityState where
-  fromJSVal = return . fmap ValidityState . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject ValidityState where
-  toGObject = GObject . unValidityState
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = ValidityState . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToValidityState :: IsGObject obj => obj -> IO ValidityState
-castToValidityState = castTo gTypeValidityState "ValidityState"
-
-foreign import javascript unsafe "window[\"ValidityState\"]" gTypeValidityState :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.VideoPlaybackQuality".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/VideoPlaybackQuality Mozilla VideoPlaybackQuality documentation>
-newtype VideoPlaybackQuality = VideoPlaybackQuality { unVideoPlaybackQuality :: JSVal }
-
-instance Eq (VideoPlaybackQuality) where
-  (VideoPlaybackQuality a) == (VideoPlaybackQuality b) = js_eq a b
-
-instance PToJSVal VideoPlaybackQuality where
-  pToJSVal = unVideoPlaybackQuality
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal VideoPlaybackQuality where
-  pFromJSVal = VideoPlaybackQuality
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal VideoPlaybackQuality where
-  toJSVal = return . unVideoPlaybackQuality
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal VideoPlaybackQuality where
-  fromJSVal = return . fmap VideoPlaybackQuality . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject VideoPlaybackQuality where
-  toGObject = GObject . unVideoPlaybackQuality
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = VideoPlaybackQuality . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToVideoPlaybackQuality :: IsGObject obj => obj -> IO VideoPlaybackQuality
-castToVideoPlaybackQuality = castTo gTypeVideoPlaybackQuality "VideoPlaybackQuality"
-
-foreign import javascript unsafe "window[\"VideoPlaybackQuality\"]" gTypeVideoPlaybackQuality :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.VideoStreamTrack".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.MediaStreamTrack"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/VideoStreamTrack Mozilla VideoStreamTrack documentation>
-newtype VideoStreamTrack = VideoStreamTrack { unVideoStreamTrack :: JSVal }
-
-instance Eq (VideoStreamTrack) where
-  (VideoStreamTrack a) == (VideoStreamTrack b) = js_eq a b
-
-instance PToJSVal VideoStreamTrack where
-  pToJSVal = unVideoStreamTrack
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal VideoStreamTrack where
-  pFromJSVal = VideoStreamTrack
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal VideoStreamTrack where
-  toJSVal = return . unVideoStreamTrack
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal VideoStreamTrack where
-  fromJSVal = return . fmap VideoStreamTrack . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsMediaStreamTrack VideoStreamTrack
-instance IsEventTarget VideoStreamTrack
-instance IsGObject VideoStreamTrack where
-  toGObject = GObject . unVideoStreamTrack
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = VideoStreamTrack . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToVideoStreamTrack :: IsGObject obj => obj -> IO VideoStreamTrack
-castToVideoStreamTrack = castTo gTypeVideoStreamTrack "VideoStreamTrack"
-
-foreign import javascript unsafe "window[\"VideoStreamTrack\"]" gTypeVideoStreamTrack :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.VideoTrack".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/VideoTrack Mozilla VideoTrack documentation>
-newtype VideoTrack = VideoTrack { unVideoTrack :: JSVal }
-
-instance Eq (VideoTrack) where
-  (VideoTrack a) == (VideoTrack b) = js_eq a b
-
-instance PToJSVal VideoTrack where
-  pToJSVal = unVideoTrack
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal VideoTrack where
-  pFromJSVal = VideoTrack
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal VideoTrack where
-  toJSVal = return . unVideoTrack
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal VideoTrack where
-  fromJSVal = return . fmap VideoTrack . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject VideoTrack where
-  toGObject = GObject . unVideoTrack
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = VideoTrack . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToVideoTrack :: IsGObject obj => obj -> IO VideoTrack
-castToVideoTrack = castTo gTypeVideoTrack "VideoTrack"
-
-foreign import javascript unsafe "window[\"VideoTrack\"]" gTypeVideoTrack :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.VideoTrackList".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/VideoTrackList Mozilla VideoTrackList documentation>
-newtype VideoTrackList = VideoTrackList { unVideoTrackList :: JSVal }
-
-instance Eq (VideoTrackList) where
-  (VideoTrackList a) == (VideoTrackList b) = js_eq a b
-
-instance PToJSVal VideoTrackList where
-  pToJSVal = unVideoTrackList
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal VideoTrackList where
-  pFromJSVal = VideoTrackList
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal VideoTrackList where
-  toJSVal = return . unVideoTrackList
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal VideoTrackList where
-  fromJSVal = return . fmap VideoTrackList . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsEventTarget VideoTrackList
-instance IsGObject VideoTrackList where
-  toGObject = GObject . unVideoTrackList
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = VideoTrackList . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToVideoTrackList :: IsGObject obj => obj -> IO VideoTrackList
-castToVideoTrackList = castTo gTypeVideoTrackList "VideoTrackList"
-
-foreign import javascript unsafe "window[\"VideoTrackList\"]" gTypeVideoTrackList :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.WaveShaperNode".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.AudioNode"
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/WaveShaperNode Mozilla WaveShaperNode documentation>
-newtype WaveShaperNode = WaveShaperNode { unWaveShaperNode :: JSVal }
-
-instance Eq (WaveShaperNode) where
-  (WaveShaperNode a) == (WaveShaperNode b) = js_eq a b
-
-instance PToJSVal WaveShaperNode where
-  pToJSVal = unWaveShaperNode
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal WaveShaperNode where
-  pFromJSVal = WaveShaperNode
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal WaveShaperNode where
-  toJSVal = return . unWaveShaperNode
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal WaveShaperNode where
-  fromJSVal = return . fmap WaveShaperNode . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsAudioNode WaveShaperNode
-instance IsEventTarget WaveShaperNode
-instance IsGObject WaveShaperNode where
-  toGObject = GObject . unWaveShaperNode
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = WaveShaperNode . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToWaveShaperNode :: IsGObject obj => obj -> IO WaveShaperNode
-castToWaveShaperNode = castTo gTypeWaveShaperNode "WaveShaperNode"
-
-foreign import javascript unsafe "window[\"WaveShaperNode\"]" gTypeWaveShaperNode :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.WebGL2RenderingContext".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.WebGLRenderingContextBase"
---     * "GHCJS.DOM.CanvasRenderingContext"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/WebGL2RenderingContext Mozilla WebGL2RenderingContext documentation>
-newtype WebGL2RenderingContext = WebGL2RenderingContext { unWebGL2RenderingContext :: JSVal }
-
-instance Eq (WebGL2RenderingContext) where
-  (WebGL2RenderingContext a) == (WebGL2RenderingContext b) = js_eq a b
-
-instance PToJSVal WebGL2RenderingContext where
-  pToJSVal = unWebGL2RenderingContext
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal WebGL2RenderingContext where
-  pFromJSVal = WebGL2RenderingContext
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal WebGL2RenderingContext where
-  toJSVal = return . unWebGL2RenderingContext
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal WebGL2RenderingContext where
-  fromJSVal = return . fmap WebGL2RenderingContext . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsWebGLRenderingContextBase WebGL2RenderingContext
-instance IsCanvasRenderingContext WebGL2RenderingContext
-instance IsGObject WebGL2RenderingContext where
-  toGObject = GObject . unWebGL2RenderingContext
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = WebGL2RenderingContext . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToWebGL2RenderingContext :: IsGObject obj => obj -> IO WebGL2RenderingContext
-castToWebGL2RenderingContext = castTo gTypeWebGL2RenderingContext "WebGL2RenderingContext"
-
-foreign import javascript unsafe "window[\"WebGL2RenderingContext\"]" gTypeWebGL2RenderingContext :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.WebGLActiveInfo".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/WebGLActiveInfo Mozilla WebGLActiveInfo documentation>
-newtype WebGLActiveInfo = WebGLActiveInfo { unWebGLActiveInfo :: JSVal }
-
-instance Eq (WebGLActiveInfo) where
-  (WebGLActiveInfo a) == (WebGLActiveInfo b) = js_eq a b
-
-instance PToJSVal WebGLActiveInfo where
-  pToJSVal = unWebGLActiveInfo
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal WebGLActiveInfo where
-  pFromJSVal = WebGLActiveInfo
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal WebGLActiveInfo where
-  toJSVal = return . unWebGLActiveInfo
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal WebGLActiveInfo where
-  fromJSVal = return . fmap WebGLActiveInfo . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject WebGLActiveInfo where
-  toGObject = GObject . unWebGLActiveInfo
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = WebGLActiveInfo . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToWebGLActiveInfo :: IsGObject obj => obj -> IO WebGLActiveInfo
-castToWebGLActiveInfo = castTo gTypeWebGLActiveInfo "WebGLActiveInfo"
-
-foreign import javascript unsafe "window[\"WebGLActiveInfo\"]" gTypeWebGLActiveInfo :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.WebGLBuffer".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/WebGLBuffer Mozilla WebGLBuffer documentation>
-newtype WebGLBuffer = WebGLBuffer { unWebGLBuffer :: JSVal }
-
-instance Eq (WebGLBuffer) where
-  (WebGLBuffer a) == (WebGLBuffer b) = js_eq a b
-
-instance PToJSVal WebGLBuffer where
-  pToJSVal = unWebGLBuffer
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal WebGLBuffer where
-  pFromJSVal = WebGLBuffer
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal WebGLBuffer where
-  toJSVal = return . unWebGLBuffer
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal WebGLBuffer where
-  fromJSVal = return . fmap WebGLBuffer . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject WebGLBuffer where
-  toGObject = GObject . unWebGLBuffer
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = WebGLBuffer . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToWebGLBuffer :: IsGObject obj => obj -> IO WebGLBuffer
-castToWebGLBuffer = castTo gTypeWebGLBuffer "WebGLBuffer"
-
-foreign import javascript unsafe "window[\"WebGLBuffer\"]" gTypeWebGLBuffer :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.WebGLCompressedTextureATC".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/WebGLCompressedTextureATC Mozilla WebGLCompressedTextureATC documentation>
-newtype WebGLCompressedTextureATC = WebGLCompressedTextureATC { unWebGLCompressedTextureATC :: JSVal }
-
-instance Eq (WebGLCompressedTextureATC) where
-  (WebGLCompressedTextureATC a) == (WebGLCompressedTextureATC b) = js_eq a b
-
-instance PToJSVal WebGLCompressedTextureATC where
-  pToJSVal = unWebGLCompressedTextureATC
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal WebGLCompressedTextureATC where
-  pFromJSVal = WebGLCompressedTextureATC
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal WebGLCompressedTextureATC where
-  toJSVal = return . unWebGLCompressedTextureATC
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal WebGLCompressedTextureATC where
-  fromJSVal = return . fmap WebGLCompressedTextureATC . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject WebGLCompressedTextureATC where
-  toGObject = GObject . unWebGLCompressedTextureATC
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = WebGLCompressedTextureATC . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToWebGLCompressedTextureATC :: IsGObject obj => obj -> IO WebGLCompressedTextureATC
-castToWebGLCompressedTextureATC = castTo gTypeWebGLCompressedTextureATC "WebGLCompressedTextureATC"
-
-foreign import javascript unsafe "window[\"WebGLCompressedTextureATC\"]" gTypeWebGLCompressedTextureATC :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.WebGLCompressedTexturePVRTC".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/WebGLCompressedTexturePVRTC Mozilla WebGLCompressedTexturePVRTC documentation>
-newtype WebGLCompressedTexturePVRTC = WebGLCompressedTexturePVRTC { unWebGLCompressedTexturePVRTC :: JSVal }
-
-instance Eq (WebGLCompressedTexturePVRTC) where
-  (WebGLCompressedTexturePVRTC a) == (WebGLCompressedTexturePVRTC b) = js_eq a b
-
-instance PToJSVal WebGLCompressedTexturePVRTC where
-  pToJSVal = unWebGLCompressedTexturePVRTC
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal WebGLCompressedTexturePVRTC where
-  pFromJSVal = WebGLCompressedTexturePVRTC
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal WebGLCompressedTexturePVRTC where
-  toJSVal = return . unWebGLCompressedTexturePVRTC
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal WebGLCompressedTexturePVRTC where
-  fromJSVal = return . fmap WebGLCompressedTexturePVRTC . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject WebGLCompressedTexturePVRTC where
-  toGObject = GObject . unWebGLCompressedTexturePVRTC
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = WebGLCompressedTexturePVRTC . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToWebGLCompressedTexturePVRTC :: IsGObject obj => obj -> IO WebGLCompressedTexturePVRTC
-castToWebGLCompressedTexturePVRTC = castTo gTypeWebGLCompressedTexturePVRTC "WebGLCompressedTexturePVRTC"
-
-foreign import javascript unsafe "window[\"WebGLCompressedTexturePVRTC\"]" gTypeWebGLCompressedTexturePVRTC :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.WebGLCompressedTextureS3TC".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/WebGLCompressedTextureS3TC Mozilla WebGLCompressedTextureS3TC documentation>
-newtype WebGLCompressedTextureS3TC = WebGLCompressedTextureS3TC { unWebGLCompressedTextureS3TC :: JSVal }
-
-instance Eq (WebGLCompressedTextureS3TC) where
-  (WebGLCompressedTextureS3TC a) == (WebGLCompressedTextureS3TC b) = js_eq a b
-
-instance PToJSVal WebGLCompressedTextureS3TC where
-  pToJSVal = unWebGLCompressedTextureS3TC
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal WebGLCompressedTextureS3TC where
-  pFromJSVal = WebGLCompressedTextureS3TC
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal WebGLCompressedTextureS3TC where
-  toJSVal = return . unWebGLCompressedTextureS3TC
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal WebGLCompressedTextureS3TC where
-  fromJSVal = return . fmap WebGLCompressedTextureS3TC . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject WebGLCompressedTextureS3TC where
-  toGObject = GObject . unWebGLCompressedTextureS3TC
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = WebGLCompressedTextureS3TC . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToWebGLCompressedTextureS3TC :: IsGObject obj => obj -> IO WebGLCompressedTextureS3TC
-castToWebGLCompressedTextureS3TC = castTo gTypeWebGLCompressedTextureS3TC "WebGLCompressedTextureS3TC"
-
-foreign import javascript unsafe "window[\"WebGLCompressedTextureS3TC\"]" gTypeWebGLCompressedTextureS3TC :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.WebGLContextAttributes".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/WebGLContextAttributes Mozilla WebGLContextAttributes documentation>
-newtype WebGLContextAttributes = WebGLContextAttributes { unWebGLContextAttributes :: JSVal }
-
-instance Eq (WebGLContextAttributes) where
-  (WebGLContextAttributes a) == (WebGLContextAttributes b) = js_eq a b
-
-instance PToJSVal WebGLContextAttributes where
-  pToJSVal = unWebGLContextAttributes
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal WebGLContextAttributes where
-  pFromJSVal = WebGLContextAttributes
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal WebGLContextAttributes where
-  toJSVal = return . unWebGLContextAttributes
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal WebGLContextAttributes where
-  fromJSVal = return . fmap WebGLContextAttributes . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject WebGLContextAttributes where
-  toGObject = GObject . unWebGLContextAttributes
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = WebGLContextAttributes . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToWebGLContextAttributes :: IsGObject obj => obj -> IO WebGLContextAttributes
-castToWebGLContextAttributes = castTo gTypeWebGLContextAttributes "WebGLContextAttributes"
-
-foreign import javascript unsafe "window[\"WebGLContextAttributes\"]" gTypeWebGLContextAttributes :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.WebGLContextEvent".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.Event"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/WebGLContextEvent Mozilla WebGLContextEvent documentation>
-newtype WebGLContextEvent = WebGLContextEvent { unWebGLContextEvent :: JSVal }
-
-instance Eq (WebGLContextEvent) where
-  (WebGLContextEvent a) == (WebGLContextEvent b) = js_eq a b
-
-instance PToJSVal WebGLContextEvent where
-  pToJSVal = unWebGLContextEvent
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal WebGLContextEvent where
-  pFromJSVal = WebGLContextEvent
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal WebGLContextEvent where
-  toJSVal = return . unWebGLContextEvent
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal WebGLContextEvent where
-  fromJSVal = return . fmap WebGLContextEvent . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsEvent WebGLContextEvent
-instance IsGObject WebGLContextEvent where
-  toGObject = GObject . unWebGLContextEvent
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = WebGLContextEvent . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToWebGLContextEvent :: IsGObject obj => obj -> IO WebGLContextEvent
-castToWebGLContextEvent = castTo gTypeWebGLContextEvent "WebGLContextEvent"
-
-foreign import javascript unsafe "window[\"WebGLContextEvent\"]" gTypeWebGLContextEvent :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.WebGLDebugRendererInfo".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/WebGLDebugRendererInfo Mozilla WebGLDebugRendererInfo documentation>
-newtype WebGLDebugRendererInfo = WebGLDebugRendererInfo { unWebGLDebugRendererInfo :: JSVal }
-
-instance Eq (WebGLDebugRendererInfo) where
-  (WebGLDebugRendererInfo a) == (WebGLDebugRendererInfo b) = js_eq a b
-
-instance PToJSVal WebGLDebugRendererInfo where
-  pToJSVal = unWebGLDebugRendererInfo
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal WebGLDebugRendererInfo where
-  pFromJSVal = WebGLDebugRendererInfo
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal WebGLDebugRendererInfo where
-  toJSVal = return . unWebGLDebugRendererInfo
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal WebGLDebugRendererInfo where
-  fromJSVal = return . fmap WebGLDebugRendererInfo . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject WebGLDebugRendererInfo where
-  toGObject = GObject . unWebGLDebugRendererInfo
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = WebGLDebugRendererInfo . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToWebGLDebugRendererInfo :: IsGObject obj => obj -> IO WebGLDebugRendererInfo
-castToWebGLDebugRendererInfo = castTo gTypeWebGLDebugRendererInfo "WebGLDebugRendererInfo"
-
-foreign import javascript unsafe "window[\"WebGLDebugRendererInfo\"]" gTypeWebGLDebugRendererInfo :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.WebGLDebugShaders".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/WebGLDebugShaders Mozilla WebGLDebugShaders documentation>
-newtype WebGLDebugShaders = WebGLDebugShaders { unWebGLDebugShaders :: JSVal }
-
-instance Eq (WebGLDebugShaders) where
-  (WebGLDebugShaders a) == (WebGLDebugShaders b) = js_eq a b
-
-instance PToJSVal WebGLDebugShaders where
-  pToJSVal = unWebGLDebugShaders
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal WebGLDebugShaders where
-  pFromJSVal = WebGLDebugShaders
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal WebGLDebugShaders where
-  toJSVal = return . unWebGLDebugShaders
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal WebGLDebugShaders where
-  fromJSVal = return . fmap WebGLDebugShaders . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject WebGLDebugShaders where
-  toGObject = GObject . unWebGLDebugShaders
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = WebGLDebugShaders . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToWebGLDebugShaders :: IsGObject obj => obj -> IO WebGLDebugShaders
-castToWebGLDebugShaders = castTo gTypeWebGLDebugShaders "WebGLDebugShaders"
-
-foreign import javascript unsafe "window[\"WebGLDebugShaders\"]" gTypeWebGLDebugShaders :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.WebGLDepthTexture".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/WebGLDepthTexture Mozilla WebGLDepthTexture documentation>
-newtype WebGLDepthTexture = WebGLDepthTexture { unWebGLDepthTexture :: JSVal }
-
-instance Eq (WebGLDepthTexture) where
-  (WebGLDepthTexture a) == (WebGLDepthTexture b) = js_eq a b
-
-instance PToJSVal WebGLDepthTexture where
-  pToJSVal = unWebGLDepthTexture
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal WebGLDepthTexture where
-  pFromJSVal = WebGLDepthTexture
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal WebGLDepthTexture where
-  toJSVal = return . unWebGLDepthTexture
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal WebGLDepthTexture where
-  fromJSVal = return . fmap WebGLDepthTexture . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject WebGLDepthTexture where
-  toGObject = GObject . unWebGLDepthTexture
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = WebGLDepthTexture . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToWebGLDepthTexture :: IsGObject obj => obj -> IO WebGLDepthTexture
-castToWebGLDepthTexture = castTo gTypeWebGLDepthTexture "WebGLDepthTexture"
-
-foreign import javascript unsafe "window[\"WebGLDepthTexture\"]" gTypeWebGLDepthTexture :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.WebGLDrawBuffers".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/WebGLDrawBuffers Mozilla WebGLDrawBuffers documentation>
-newtype WebGLDrawBuffers = WebGLDrawBuffers { unWebGLDrawBuffers :: JSVal }
-
-instance Eq (WebGLDrawBuffers) where
-  (WebGLDrawBuffers a) == (WebGLDrawBuffers b) = js_eq a b
-
-instance PToJSVal WebGLDrawBuffers where
-  pToJSVal = unWebGLDrawBuffers
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal WebGLDrawBuffers where
-  pFromJSVal = WebGLDrawBuffers
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal WebGLDrawBuffers where
-  toJSVal = return . unWebGLDrawBuffers
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal WebGLDrawBuffers where
-  fromJSVal = return . fmap WebGLDrawBuffers . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject WebGLDrawBuffers where
-  toGObject = GObject . unWebGLDrawBuffers
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = WebGLDrawBuffers . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToWebGLDrawBuffers :: IsGObject obj => obj -> IO WebGLDrawBuffers
-castToWebGLDrawBuffers = castTo gTypeWebGLDrawBuffers "WebGLDrawBuffers"
-
-foreign import javascript unsafe "window[\"WebGLDrawBuffers\"]" gTypeWebGLDrawBuffers :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.WebGLFramebuffer".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/WebGLFramebuffer Mozilla WebGLFramebuffer documentation>
-newtype WebGLFramebuffer = WebGLFramebuffer { unWebGLFramebuffer :: JSVal }
-
-instance Eq (WebGLFramebuffer) where
-  (WebGLFramebuffer a) == (WebGLFramebuffer b) = js_eq a b
-
-instance PToJSVal WebGLFramebuffer where
-  pToJSVal = unWebGLFramebuffer
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal WebGLFramebuffer where
-  pFromJSVal = WebGLFramebuffer
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal WebGLFramebuffer where
-  toJSVal = return . unWebGLFramebuffer
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal WebGLFramebuffer where
-  fromJSVal = return . fmap WebGLFramebuffer . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject WebGLFramebuffer where
-  toGObject = GObject . unWebGLFramebuffer
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = WebGLFramebuffer . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToWebGLFramebuffer :: IsGObject obj => obj -> IO WebGLFramebuffer
-castToWebGLFramebuffer = castTo gTypeWebGLFramebuffer "WebGLFramebuffer"
-
-foreign import javascript unsafe "window[\"WebGLFramebuffer\"]" gTypeWebGLFramebuffer :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.WebGLLoseContext".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/WebGLLoseContext Mozilla WebGLLoseContext documentation>
-newtype WebGLLoseContext = WebGLLoseContext { unWebGLLoseContext :: JSVal }
-
-instance Eq (WebGLLoseContext) where
-  (WebGLLoseContext a) == (WebGLLoseContext b) = js_eq a b
-
-instance PToJSVal WebGLLoseContext where
-  pToJSVal = unWebGLLoseContext
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal WebGLLoseContext where
-  pFromJSVal = WebGLLoseContext
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal WebGLLoseContext where
-  toJSVal = return . unWebGLLoseContext
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal WebGLLoseContext where
-  fromJSVal = return . fmap WebGLLoseContext . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject WebGLLoseContext where
-  toGObject = GObject . unWebGLLoseContext
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = WebGLLoseContext . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToWebGLLoseContext :: IsGObject obj => obj -> IO WebGLLoseContext
-castToWebGLLoseContext = castTo gTypeWebGLLoseContext "WebGLLoseContext"
-
-foreign import javascript unsafe "window[\"WebGLLoseContext\"]" gTypeWebGLLoseContext :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.WebGLProgram".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/WebGLProgram Mozilla WebGLProgram documentation>
-newtype WebGLProgram = WebGLProgram { unWebGLProgram :: JSVal }
-
-instance Eq (WebGLProgram) where
-  (WebGLProgram a) == (WebGLProgram b) = js_eq a b
-
-instance PToJSVal WebGLProgram where
-  pToJSVal = unWebGLProgram
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal WebGLProgram where
-  pFromJSVal = WebGLProgram
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal WebGLProgram where
-  toJSVal = return . unWebGLProgram
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal WebGLProgram where
-  fromJSVal = return . fmap WebGLProgram . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject WebGLProgram where
-  toGObject = GObject . unWebGLProgram
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = WebGLProgram . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToWebGLProgram :: IsGObject obj => obj -> IO WebGLProgram
-castToWebGLProgram = castTo gTypeWebGLProgram "WebGLProgram"
-
-foreign import javascript unsafe "window[\"WebGLProgram\"]" gTypeWebGLProgram :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.WebGLQuery".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/WebGLQuery Mozilla WebGLQuery documentation>
-newtype WebGLQuery = WebGLQuery { unWebGLQuery :: JSVal }
-
-instance Eq (WebGLQuery) where
-  (WebGLQuery a) == (WebGLQuery b) = js_eq a b
-
-instance PToJSVal WebGLQuery where
-  pToJSVal = unWebGLQuery
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal WebGLQuery where
-  pFromJSVal = WebGLQuery
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal WebGLQuery where
-  toJSVal = return . unWebGLQuery
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal WebGLQuery where
-  fromJSVal = return . fmap WebGLQuery . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject WebGLQuery where
-  toGObject = GObject . unWebGLQuery
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = WebGLQuery . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToWebGLQuery :: IsGObject obj => obj -> IO WebGLQuery
-castToWebGLQuery = castTo gTypeWebGLQuery "WebGLQuery"
-
-foreign import javascript unsafe "window[\"WebGLQuery\"]" gTypeWebGLQuery :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.WebGLRenderbuffer".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/WebGLRenderbuffer Mozilla WebGLRenderbuffer documentation>
-newtype WebGLRenderbuffer = WebGLRenderbuffer { unWebGLRenderbuffer :: JSVal }
-
-instance Eq (WebGLRenderbuffer) where
-  (WebGLRenderbuffer a) == (WebGLRenderbuffer b) = js_eq a b
-
-instance PToJSVal WebGLRenderbuffer where
-  pToJSVal = unWebGLRenderbuffer
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal WebGLRenderbuffer where
-  pFromJSVal = WebGLRenderbuffer
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal WebGLRenderbuffer where
-  toJSVal = return . unWebGLRenderbuffer
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal WebGLRenderbuffer where
-  fromJSVal = return . fmap WebGLRenderbuffer . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject WebGLRenderbuffer where
-  toGObject = GObject . unWebGLRenderbuffer
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = WebGLRenderbuffer . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToWebGLRenderbuffer :: IsGObject obj => obj -> IO WebGLRenderbuffer
-castToWebGLRenderbuffer = castTo gTypeWebGLRenderbuffer "WebGLRenderbuffer"
-
-foreign import javascript unsafe "window[\"WebGLRenderbuffer\"]" gTypeWebGLRenderbuffer :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.WebGLRenderingContext".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.WebGLRenderingContextBase"
---     * "GHCJS.DOM.CanvasRenderingContext"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/WebGLRenderingContext Mozilla WebGLRenderingContext documentation>
-newtype WebGLRenderingContext = WebGLRenderingContext { unWebGLRenderingContext :: JSVal }
-
-instance Eq (WebGLRenderingContext) where
-  (WebGLRenderingContext a) == (WebGLRenderingContext b) = js_eq a b
-
-instance PToJSVal WebGLRenderingContext where
-  pToJSVal = unWebGLRenderingContext
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal WebGLRenderingContext where
-  pFromJSVal = WebGLRenderingContext
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal WebGLRenderingContext where
-  toJSVal = return . unWebGLRenderingContext
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal WebGLRenderingContext where
-  fromJSVal = return . fmap WebGLRenderingContext . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsWebGLRenderingContextBase WebGLRenderingContext
-instance IsCanvasRenderingContext WebGLRenderingContext
-instance IsGObject WebGLRenderingContext where
-  toGObject = GObject . unWebGLRenderingContext
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = WebGLRenderingContext . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToWebGLRenderingContext :: IsGObject obj => obj -> IO WebGLRenderingContext
-castToWebGLRenderingContext = castTo gTypeWebGLRenderingContext "WebGLRenderingContext"
-
-foreign import javascript unsafe "window[\"WebGLRenderingContext\"]" gTypeWebGLRenderingContext :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.WebGLRenderingContextBase".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.CanvasRenderingContext"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/WebGLRenderingContextBase Mozilla WebGLRenderingContextBase documentation>
-newtype WebGLRenderingContextBase = WebGLRenderingContextBase { unWebGLRenderingContextBase :: JSVal }
-
-instance Eq (WebGLRenderingContextBase) where
-  (WebGLRenderingContextBase a) == (WebGLRenderingContextBase b) = js_eq a b
-
-instance PToJSVal WebGLRenderingContextBase where
-  pToJSVal = unWebGLRenderingContextBase
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal WebGLRenderingContextBase where
-  pFromJSVal = WebGLRenderingContextBase
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal WebGLRenderingContextBase where
-  toJSVal = return . unWebGLRenderingContextBase
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal WebGLRenderingContextBase where
-  fromJSVal = return . fmap WebGLRenderingContextBase . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-class IsCanvasRenderingContext o => IsWebGLRenderingContextBase o
-toWebGLRenderingContextBase :: IsWebGLRenderingContextBase o => o -> WebGLRenderingContextBase
-toWebGLRenderingContextBase = unsafeCastGObject . toGObject
-
-instance IsWebGLRenderingContextBase WebGLRenderingContextBase
-instance IsCanvasRenderingContext WebGLRenderingContextBase
-instance IsGObject WebGLRenderingContextBase where
-  toGObject = GObject . unWebGLRenderingContextBase
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = WebGLRenderingContextBase . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToWebGLRenderingContextBase :: IsGObject obj => obj -> IO WebGLRenderingContextBase
-castToWebGLRenderingContextBase = castTo gTypeWebGLRenderingContextBase "WebGLRenderingContextBase"
-
-foreign import javascript unsafe "window[\"WebGLRenderingContextBase\"]" gTypeWebGLRenderingContextBase :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.WebGLSampler".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/WebGLSampler Mozilla WebGLSampler documentation>
-newtype WebGLSampler = WebGLSampler { unWebGLSampler :: JSVal }
-
-instance Eq (WebGLSampler) where
-  (WebGLSampler a) == (WebGLSampler b) = js_eq a b
-
-instance PToJSVal WebGLSampler where
-  pToJSVal = unWebGLSampler
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal WebGLSampler where
-  pFromJSVal = WebGLSampler
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal WebGLSampler where
-  toJSVal = return . unWebGLSampler
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal WebGLSampler where
-  fromJSVal = return . fmap WebGLSampler . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject WebGLSampler where
-  toGObject = GObject . unWebGLSampler
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = WebGLSampler . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToWebGLSampler :: IsGObject obj => obj -> IO WebGLSampler
-castToWebGLSampler = castTo gTypeWebGLSampler "WebGLSampler"
-
-foreign import javascript unsafe "window[\"WebGLSampler\"]" gTypeWebGLSampler :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.WebGLShader".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/WebGLShader Mozilla WebGLShader documentation>
-newtype WebGLShader = WebGLShader { unWebGLShader :: JSVal }
-
-instance Eq (WebGLShader) where
-  (WebGLShader a) == (WebGLShader b) = js_eq a b
-
-instance PToJSVal WebGLShader where
-  pToJSVal = unWebGLShader
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal WebGLShader where
-  pFromJSVal = WebGLShader
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal WebGLShader where
-  toJSVal = return . unWebGLShader
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal WebGLShader where
-  fromJSVal = return . fmap WebGLShader . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject WebGLShader where
-  toGObject = GObject . unWebGLShader
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = WebGLShader . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToWebGLShader :: IsGObject obj => obj -> IO WebGLShader
-castToWebGLShader = castTo gTypeWebGLShader "WebGLShader"
-
-foreign import javascript unsafe "window[\"WebGLShader\"]" gTypeWebGLShader :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.WebGLShaderPrecisionFormat".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/WebGLShaderPrecisionFormat Mozilla WebGLShaderPrecisionFormat documentation>
-newtype WebGLShaderPrecisionFormat = WebGLShaderPrecisionFormat { unWebGLShaderPrecisionFormat :: JSVal }
-
-instance Eq (WebGLShaderPrecisionFormat) where
-  (WebGLShaderPrecisionFormat a) == (WebGLShaderPrecisionFormat b) = js_eq a b
-
-instance PToJSVal WebGLShaderPrecisionFormat where
-  pToJSVal = unWebGLShaderPrecisionFormat
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal WebGLShaderPrecisionFormat where
-  pFromJSVal = WebGLShaderPrecisionFormat
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal WebGLShaderPrecisionFormat where
-  toJSVal = return . unWebGLShaderPrecisionFormat
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal WebGLShaderPrecisionFormat where
-  fromJSVal = return . fmap WebGLShaderPrecisionFormat . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject WebGLShaderPrecisionFormat where
-  toGObject = GObject . unWebGLShaderPrecisionFormat
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = WebGLShaderPrecisionFormat . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToWebGLShaderPrecisionFormat :: IsGObject obj => obj -> IO WebGLShaderPrecisionFormat
-castToWebGLShaderPrecisionFormat = castTo gTypeWebGLShaderPrecisionFormat "WebGLShaderPrecisionFormat"
-
-foreign import javascript unsafe "window[\"WebGLShaderPrecisionFormat\"]" gTypeWebGLShaderPrecisionFormat :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.WebGLSync".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/WebGLSync Mozilla WebGLSync documentation>
-newtype WebGLSync = WebGLSync { unWebGLSync :: JSVal }
-
-instance Eq (WebGLSync) where
-  (WebGLSync a) == (WebGLSync b) = js_eq a b
-
-instance PToJSVal WebGLSync where
-  pToJSVal = unWebGLSync
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal WebGLSync where
-  pFromJSVal = WebGLSync
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal WebGLSync where
-  toJSVal = return . unWebGLSync
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal WebGLSync where
-  fromJSVal = return . fmap WebGLSync . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject WebGLSync where
-  toGObject = GObject . unWebGLSync
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = WebGLSync . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToWebGLSync :: IsGObject obj => obj -> IO WebGLSync
-castToWebGLSync = castTo gTypeWebGLSync "WebGLSync"
-
-foreign import javascript unsafe "window[\"WebGLSync\"]" gTypeWebGLSync :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.WebGLTexture".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/WebGLTexture Mozilla WebGLTexture documentation>
-newtype WebGLTexture = WebGLTexture { unWebGLTexture :: JSVal }
-
-instance Eq (WebGLTexture) where
-  (WebGLTexture a) == (WebGLTexture b) = js_eq a b
-
-instance PToJSVal WebGLTexture where
-  pToJSVal = unWebGLTexture
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal WebGLTexture where
-  pFromJSVal = WebGLTexture
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal WebGLTexture where
-  toJSVal = return . unWebGLTexture
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal WebGLTexture where
-  fromJSVal = return . fmap WebGLTexture . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject WebGLTexture where
-  toGObject = GObject . unWebGLTexture
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = WebGLTexture . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToWebGLTexture :: IsGObject obj => obj -> IO WebGLTexture
-castToWebGLTexture = castTo gTypeWebGLTexture "WebGLTexture"
-
-foreign import javascript unsafe "window[\"WebGLTexture\"]" gTypeWebGLTexture :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.WebGLTransformFeedback".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/WebGLTransformFeedback Mozilla WebGLTransformFeedback documentation>
-newtype WebGLTransformFeedback = WebGLTransformFeedback { unWebGLTransformFeedback :: JSVal }
-
-instance Eq (WebGLTransformFeedback) where
-  (WebGLTransformFeedback a) == (WebGLTransformFeedback b) = js_eq a b
-
-instance PToJSVal WebGLTransformFeedback where
-  pToJSVal = unWebGLTransformFeedback
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal WebGLTransformFeedback where
-  pFromJSVal = WebGLTransformFeedback
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal WebGLTransformFeedback where
-  toJSVal = return . unWebGLTransformFeedback
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal WebGLTransformFeedback where
-  fromJSVal = return . fmap WebGLTransformFeedback . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject WebGLTransformFeedback where
-  toGObject = GObject . unWebGLTransformFeedback
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = WebGLTransformFeedback . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToWebGLTransformFeedback :: IsGObject obj => obj -> IO WebGLTransformFeedback
-castToWebGLTransformFeedback = castTo gTypeWebGLTransformFeedback "WebGLTransformFeedback"
-
-foreign import javascript unsafe "window[\"WebGLTransformFeedback\"]" gTypeWebGLTransformFeedback :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.WebGLUniformLocation".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/WebGLUniformLocation Mozilla WebGLUniformLocation documentation>
-newtype WebGLUniformLocation = WebGLUniformLocation { unWebGLUniformLocation :: JSVal }
-
-instance Eq (WebGLUniformLocation) where
-  (WebGLUniformLocation a) == (WebGLUniformLocation b) = js_eq a b
-
-instance PToJSVal WebGLUniformLocation where
-  pToJSVal = unWebGLUniformLocation
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal WebGLUniformLocation where
-  pFromJSVal = WebGLUniformLocation
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal WebGLUniformLocation where
-  toJSVal = return . unWebGLUniformLocation
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal WebGLUniformLocation where
-  fromJSVal = return . fmap WebGLUniformLocation . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject WebGLUniformLocation where
-  toGObject = GObject . unWebGLUniformLocation
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = WebGLUniformLocation . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToWebGLUniformLocation :: IsGObject obj => obj -> IO WebGLUniformLocation
-castToWebGLUniformLocation = castTo gTypeWebGLUniformLocation "WebGLUniformLocation"
-
-foreign import javascript unsafe "window[\"WebGLUniformLocation\"]" gTypeWebGLUniformLocation :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.WebGLVertexArrayObject".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/WebGLVertexArrayObject Mozilla WebGLVertexArrayObject documentation>
-newtype WebGLVertexArrayObject = WebGLVertexArrayObject { unWebGLVertexArrayObject :: JSVal }
-
-instance Eq (WebGLVertexArrayObject) where
-  (WebGLVertexArrayObject a) == (WebGLVertexArrayObject b) = js_eq a b
-
-instance PToJSVal WebGLVertexArrayObject where
-  pToJSVal = unWebGLVertexArrayObject
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal WebGLVertexArrayObject where
-  pFromJSVal = WebGLVertexArrayObject
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal WebGLVertexArrayObject where
-  toJSVal = return . unWebGLVertexArrayObject
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal WebGLVertexArrayObject where
-  fromJSVal = return . fmap WebGLVertexArrayObject . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject WebGLVertexArrayObject where
-  toGObject = GObject . unWebGLVertexArrayObject
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = WebGLVertexArrayObject . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToWebGLVertexArrayObject :: IsGObject obj => obj -> IO WebGLVertexArrayObject
-castToWebGLVertexArrayObject = castTo gTypeWebGLVertexArrayObject "WebGLVertexArrayObject"
-
-foreign import javascript unsafe "window[\"WebGLVertexArrayObject\"]" gTypeWebGLVertexArrayObject :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.WebGLVertexArrayObjectOES".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/WebGLVertexArrayObjectOES Mozilla WebGLVertexArrayObjectOES documentation>
-newtype WebGLVertexArrayObjectOES = WebGLVertexArrayObjectOES { unWebGLVertexArrayObjectOES :: JSVal }
-
-instance Eq (WebGLVertexArrayObjectOES) where
-  (WebGLVertexArrayObjectOES a) == (WebGLVertexArrayObjectOES b) = js_eq a b
-
-instance PToJSVal WebGLVertexArrayObjectOES where
-  pToJSVal = unWebGLVertexArrayObjectOES
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal WebGLVertexArrayObjectOES where
-  pFromJSVal = WebGLVertexArrayObjectOES
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal WebGLVertexArrayObjectOES where
-  toJSVal = return . unWebGLVertexArrayObjectOES
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal WebGLVertexArrayObjectOES where
-  fromJSVal = return . fmap WebGLVertexArrayObjectOES . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject WebGLVertexArrayObjectOES where
-  toGObject = GObject . unWebGLVertexArrayObjectOES
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = WebGLVertexArrayObjectOES . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToWebGLVertexArrayObjectOES :: IsGObject obj => obj -> IO WebGLVertexArrayObjectOES
-castToWebGLVertexArrayObjectOES = castTo gTypeWebGLVertexArrayObjectOES "WebGLVertexArrayObjectOES"
-
-foreign import javascript unsafe "window[\"WebGLVertexArrayObjectOES\"]" gTypeWebGLVertexArrayObjectOES :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.WebKitAnimationEvent".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.Event"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/WebKitAnimationEvent Mozilla WebKitAnimationEvent documentation>
-newtype WebKitAnimationEvent = WebKitAnimationEvent { unWebKitAnimationEvent :: JSVal }
-
-instance Eq (WebKitAnimationEvent) where
-  (WebKitAnimationEvent a) == (WebKitAnimationEvent b) = js_eq a b
-
-instance PToJSVal WebKitAnimationEvent where
-  pToJSVal = unWebKitAnimationEvent
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal WebKitAnimationEvent where
-  pFromJSVal = WebKitAnimationEvent
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal WebKitAnimationEvent where
-  toJSVal = return . unWebKitAnimationEvent
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal WebKitAnimationEvent where
-  fromJSVal = return . fmap WebKitAnimationEvent . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsEvent WebKitAnimationEvent
-instance IsGObject WebKitAnimationEvent where
-  toGObject = GObject . unWebKitAnimationEvent
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = WebKitAnimationEvent . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToWebKitAnimationEvent :: IsGObject obj => obj -> IO WebKitAnimationEvent
-castToWebKitAnimationEvent = castTo gTypeWebKitAnimationEvent "WebKitAnimationEvent"
-
-foreign import javascript unsafe "window[\"WebKitAnimationEvent\"]" gTypeWebKitAnimationEvent :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.WebKitCSSFilterValue".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.CSSValueList"
---     * "GHCJS.DOM.CSSValue"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/WebKitCSSFilterValue Mozilla WebKitCSSFilterValue documentation>
-newtype WebKitCSSFilterValue = WebKitCSSFilterValue { unWebKitCSSFilterValue :: JSVal }
-
-instance Eq (WebKitCSSFilterValue) where
-  (WebKitCSSFilterValue a) == (WebKitCSSFilterValue b) = js_eq a b
-
-instance PToJSVal WebKitCSSFilterValue where
-  pToJSVal = unWebKitCSSFilterValue
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal WebKitCSSFilterValue where
-  pFromJSVal = WebKitCSSFilterValue
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal WebKitCSSFilterValue where
-  toJSVal = return . unWebKitCSSFilterValue
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal WebKitCSSFilterValue where
-  fromJSVal = return . fmap WebKitCSSFilterValue . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsCSSValueList WebKitCSSFilterValue
-instance IsCSSValue WebKitCSSFilterValue
-instance IsGObject WebKitCSSFilterValue where
-  toGObject = GObject . unWebKitCSSFilterValue
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = WebKitCSSFilterValue . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToWebKitCSSFilterValue :: IsGObject obj => obj -> IO WebKitCSSFilterValue
-castToWebKitCSSFilterValue = castTo gTypeWebKitCSSFilterValue "WebKitCSSFilterValue"
-
-foreign import javascript unsafe "window[\"WebKitCSSFilterValue\"]" gTypeWebKitCSSFilterValue :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.WebKitCSSMatrix".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/WebKitCSSMatrix Mozilla WebKitCSSMatrix documentation>
-newtype WebKitCSSMatrix = WebKitCSSMatrix { unWebKitCSSMatrix :: JSVal }
-
-instance Eq (WebKitCSSMatrix) where
-  (WebKitCSSMatrix a) == (WebKitCSSMatrix b) = js_eq a b
-
-instance PToJSVal WebKitCSSMatrix where
-  pToJSVal = unWebKitCSSMatrix
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal WebKitCSSMatrix where
-  pFromJSVal = WebKitCSSMatrix
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal WebKitCSSMatrix where
-  toJSVal = return . unWebKitCSSMatrix
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal WebKitCSSMatrix where
-  fromJSVal = return . fmap WebKitCSSMatrix . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject WebKitCSSMatrix where
-  toGObject = GObject . unWebKitCSSMatrix
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = WebKitCSSMatrix . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToWebKitCSSMatrix :: IsGObject obj => obj -> IO WebKitCSSMatrix
-castToWebKitCSSMatrix = castTo gTypeWebKitCSSMatrix "WebKitCSSMatrix"
-
-foreign import javascript unsafe "window[\"WebKitCSSMatrix\"]" gTypeWebKitCSSMatrix :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.WebKitCSSRegionRule".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.CSSRule"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/WebKitCSSRegionRule Mozilla WebKitCSSRegionRule documentation>
-newtype WebKitCSSRegionRule = WebKitCSSRegionRule { unWebKitCSSRegionRule :: JSVal }
-
-instance Eq (WebKitCSSRegionRule) where
-  (WebKitCSSRegionRule a) == (WebKitCSSRegionRule b) = js_eq a b
-
-instance PToJSVal WebKitCSSRegionRule where
-  pToJSVal = unWebKitCSSRegionRule
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal WebKitCSSRegionRule where
-  pFromJSVal = WebKitCSSRegionRule
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal WebKitCSSRegionRule where
-  toJSVal = return . unWebKitCSSRegionRule
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal WebKitCSSRegionRule where
-  fromJSVal = return . fmap WebKitCSSRegionRule . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsCSSRule WebKitCSSRegionRule
-instance IsGObject WebKitCSSRegionRule where
-  toGObject = GObject . unWebKitCSSRegionRule
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = WebKitCSSRegionRule . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToWebKitCSSRegionRule :: IsGObject obj => obj -> IO WebKitCSSRegionRule
-castToWebKitCSSRegionRule = castTo gTypeWebKitCSSRegionRule "WebKitCSSRegionRule"
-
-foreign import javascript unsafe "window[\"WebKitCSSRegionRule\"]" gTypeWebKitCSSRegionRule :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.WebKitCSSTransformValue".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.CSSValueList"
---     * "GHCJS.DOM.CSSValue"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/WebKitCSSTransformValue Mozilla WebKitCSSTransformValue documentation>
-newtype WebKitCSSTransformValue = WebKitCSSTransformValue { unWebKitCSSTransformValue :: JSVal }
-
-instance Eq (WebKitCSSTransformValue) where
-  (WebKitCSSTransformValue a) == (WebKitCSSTransformValue b) = js_eq a b
-
-instance PToJSVal WebKitCSSTransformValue where
-  pToJSVal = unWebKitCSSTransformValue
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal WebKitCSSTransformValue where
-  pFromJSVal = WebKitCSSTransformValue
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal WebKitCSSTransformValue where
-  toJSVal = return . unWebKitCSSTransformValue
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal WebKitCSSTransformValue where
-  fromJSVal = return . fmap WebKitCSSTransformValue . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsCSSValueList WebKitCSSTransformValue
-instance IsCSSValue WebKitCSSTransformValue
-instance IsGObject WebKitCSSTransformValue where
-  toGObject = GObject . unWebKitCSSTransformValue
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = WebKitCSSTransformValue . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToWebKitCSSTransformValue :: IsGObject obj => obj -> IO WebKitCSSTransformValue
-castToWebKitCSSTransformValue = castTo gTypeWebKitCSSTransformValue "WebKitCSSTransformValue"
-
-foreign import javascript unsafe "window[\"WebKitCSSTransformValue\"]" gTypeWebKitCSSTransformValue :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.WebKitCSSViewportRule".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.CSSRule"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/WebKitCSSViewportRule Mozilla WebKitCSSViewportRule documentation>
-newtype WebKitCSSViewportRule = WebKitCSSViewportRule { unWebKitCSSViewportRule :: JSVal }
-
-instance Eq (WebKitCSSViewportRule) where
-  (WebKitCSSViewportRule a) == (WebKitCSSViewportRule b) = js_eq a b
-
-instance PToJSVal WebKitCSSViewportRule where
-  pToJSVal = unWebKitCSSViewportRule
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal WebKitCSSViewportRule where
-  pFromJSVal = WebKitCSSViewportRule
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal WebKitCSSViewportRule where
-  toJSVal = return . unWebKitCSSViewportRule
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal WebKitCSSViewportRule where
-  fromJSVal = return . fmap WebKitCSSViewportRule . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsCSSRule WebKitCSSViewportRule
-instance IsGObject WebKitCSSViewportRule where
-  toGObject = GObject . unWebKitCSSViewportRule
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = WebKitCSSViewportRule . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToWebKitCSSViewportRule :: IsGObject obj => obj -> IO WebKitCSSViewportRule
-castToWebKitCSSViewportRule = castTo gTypeWebKitCSSViewportRule "WebKitCSSViewportRule"
-
-foreign import javascript unsafe "window[\"WebKitCSSViewportRule\"]" gTypeWebKitCSSViewportRule :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.WebKitNamedFlow".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/WebKitNamedFlow Mozilla WebKitNamedFlow documentation>
-newtype WebKitNamedFlow = WebKitNamedFlow { unWebKitNamedFlow :: JSVal }
-
-instance Eq (WebKitNamedFlow) where
-  (WebKitNamedFlow a) == (WebKitNamedFlow b) = js_eq a b
-
-instance PToJSVal WebKitNamedFlow where
-  pToJSVal = unWebKitNamedFlow
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal WebKitNamedFlow where
-  pFromJSVal = WebKitNamedFlow
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal WebKitNamedFlow where
-  toJSVal = return . unWebKitNamedFlow
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal WebKitNamedFlow where
-  fromJSVal = return . fmap WebKitNamedFlow . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsEventTarget WebKitNamedFlow
-instance IsGObject WebKitNamedFlow where
-  toGObject = GObject . unWebKitNamedFlow
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = WebKitNamedFlow . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToWebKitNamedFlow :: IsGObject obj => obj -> IO WebKitNamedFlow
-castToWebKitNamedFlow = castTo gTypeWebKitNamedFlow "WebKitNamedFlow"
-
-foreign import javascript unsafe "window[\"WebKitNamedFlow\"]" gTypeWebKitNamedFlow :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.WebKitNamespace".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/WebKitNamespace Mozilla WebKitNamespace documentation>
-newtype WebKitNamespace = WebKitNamespace { unWebKitNamespace :: JSVal }
-
-instance Eq (WebKitNamespace) where
-  (WebKitNamespace a) == (WebKitNamespace b) = js_eq a b
-
-instance PToJSVal WebKitNamespace where
-  pToJSVal = unWebKitNamespace
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal WebKitNamespace where
-  pFromJSVal = WebKitNamespace
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal WebKitNamespace where
-  toJSVal = return . unWebKitNamespace
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal WebKitNamespace where
-  fromJSVal = return . fmap WebKitNamespace . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject WebKitNamespace where
-  toGObject = GObject . unWebKitNamespace
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = WebKitNamespace . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToWebKitNamespace :: IsGObject obj => obj -> IO WebKitNamespace
-castToWebKitNamespace = castTo gTypeWebKitNamespace "WebKitNamespace"
-
-foreign import javascript unsafe "window[\"WebKitNamespace\"]" gTypeWebKitNamespace :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.WebKitPlaybackTargetAvailabilityEvent".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.Event"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/WebKitPlaybackTargetAvailabilityEvent Mozilla WebKitPlaybackTargetAvailabilityEvent documentation>
-newtype WebKitPlaybackTargetAvailabilityEvent = WebKitPlaybackTargetAvailabilityEvent { unWebKitPlaybackTargetAvailabilityEvent :: JSVal }
-
-instance Eq (WebKitPlaybackTargetAvailabilityEvent) where
-  (WebKitPlaybackTargetAvailabilityEvent a) == (WebKitPlaybackTargetAvailabilityEvent b) = js_eq a b
-
-instance PToJSVal WebKitPlaybackTargetAvailabilityEvent where
-  pToJSVal = unWebKitPlaybackTargetAvailabilityEvent
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal WebKitPlaybackTargetAvailabilityEvent where
-  pFromJSVal = WebKitPlaybackTargetAvailabilityEvent
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal WebKitPlaybackTargetAvailabilityEvent where
-  toJSVal = return . unWebKitPlaybackTargetAvailabilityEvent
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal WebKitPlaybackTargetAvailabilityEvent where
-  fromJSVal = return . fmap WebKitPlaybackTargetAvailabilityEvent . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsEvent WebKitPlaybackTargetAvailabilityEvent
-instance IsGObject WebKitPlaybackTargetAvailabilityEvent where
-  toGObject = GObject . unWebKitPlaybackTargetAvailabilityEvent
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = WebKitPlaybackTargetAvailabilityEvent . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToWebKitPlaybackTargetAvailabilityEvent :: IsGObject obj => obj -> IO WebKitPlaybackTargetAvailabilityEvent
-castToWebKitPlaybackTargetAvailabilityEvent = castTo gTypeWebKitPlaybackTargetAvailabilityEvent "WebKitPlaybackTargetAvailabilityEvent"
-
-foreign import javascript unsafe "window[\"WebKitPlaybackTargetAvailabilityEvent\"]" gTypeWebKitPlaybackTargetAvailabilityEvent :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.WebKitPoint".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/WebKitPoint Mozilla WebKitPoint documentation>
-newtype WebKitPoint = WebKitPoint { unWebKitPoint :: JSVal }
-
-instance Eq (WebKitPoint) where
-  (WebKitPoint a) == (WebKitPoint b) = js_eq a b
-
-instance PToJSVal WebKitPoint where
-  pToJSVal = unWebKitPoint
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal WebKitPoint where
-  pFromJSVal = WebKitPoint
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal WebKitPoint where
-  toJSVal = return . unWebKitPoint
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal WebKitPoint where
-  fromJSVal = return . fmap WebKitPoint . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject WebKitPoint where
-  toGObject = GObject . unWebKitPoint
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = WebKitPoint . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToWebKitPoint :: IsGObject obj => obj -> IO WebKitPoint
-castToWebKitPoint = castTo gTypeWebKitPoint "WebKitPoint"
-
-foreign import javascript unsafe "window[\"WebKitPoint\"]" gTypeWebKitPoint :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.WebKitTransitionEvent".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.Event"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/WebKitTransitionEvent Mozilla WebKitTransitionEvent documentation>
-newtype WebKitTransitionEvent = WebKitTransitionEvent { unWebKitTransitionEvent :: JSVal }
-
-instance Eq (WebKitTransitionEvent) where
-  (WebKitTransitionEvent a) == (WebKitTransitionEvent b) = js_eq a b
-
-instance PToJSVal WebKitTransitionEvent where
-  pToJSVal = unWebKitTransitionEvent
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal WebKitTransitionEvent where
-  pFromJSVal = WebKitTransitionEvent
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal WebKitTransitionEvent where
-  toJSVal = return . unWebKitTransitionEvent
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal WebKitTransitionEvent where
-  fromJSVal = return . fmap WebKitTransitionEvent . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsEvent WebKitTransitionEvent
-instance IsGObject WebKitTransitionEvent where
-  toGObject = GObject . unWebKitTransitionEvent
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = WebKitTransitionEvent . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToWebKitTransitionEvent :: IsGObject obj => obj -> IO WebKitTransitionEvent
-castToWebKitTransitionEvent = castTo gTypeWebKitTransitionEvent "WebKitTransitionEvent"
-
-foreign import javascript unsafe "window[\"WebKitTransitionEvent\"]" gTypeWebKitTransitionEvent :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.WebSocket".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/WebSocket Mozilla WebSocket documentation>
-newtype WebSocket = WebSocket { unWebSocket :: JSVal }
-
-instance Eq (WebSocket) where
-  (WebSocket a) == (WebSocket b) = js_eq a b
-
-instance PToJSVal WebSocket where
-  pToJSVal = unWebSocket
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal WebSocket where
-  pFromJSVal = WebSocket
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal WebSocket where
-  toJSVal = return . unWebSocket
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal WebSocket where
-  fromJSVal = return . fmap WebSocket . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsEventTarget WebSocket
-instance IsGObject WebSocket where
-  toGObject = GObject . unWebSocket
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = WebSocket . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToWebSocket :: IsGObject obj => obj -> IO WebSocket
-castToWebSocket = castTo gTypeWebSocket "WebSocket"
-
-foreign import javascript unsafe "window[\"WebSocket\"]" gTypeWebSocket :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.WheelEvent".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.MouseEvent"
---     * "GHCJS.DOM.UIEvent"
---     * "GHCJS.DOM.Event"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/WheelEvent Mozilla WheelEvent documentation>
-newtype WheelEvent = WheelEvent { unWheelEvent :: JSVal }
-
-instance Eq (WheelEvent) where
-  (WheelEvent a) == (WheelEvent b) = js_eq a b
-
-instance PToJSVal WheelEvent where
-  pToJSVal = unWheelEvent
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal WheelEvent where
-  pFromJSVal = WheelEvent
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal WheelEvent where
-  toJSVal = return . unWheelEvent
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal WheelEvent where
-  fromJSVal = return . fmap WheelEvent . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsMouseEvent WheelEvent
-instance IsUIEvent WheelEvent
-instance IsEvent WheelEvent
-instance IsGObject WheelEvent where
-  toGObject = GObject . unWheelEvent
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = WheelEvent . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToWheelEvent :: IsGObject obj => obj -> IO WheelEvent
-castToWheelEvent = castTo gTypeWheelEvent "WheelEvent"
-
-foreign import javascript unsafe "window[\"WheelEvent\"]" gTypeWheelEvent :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.Window".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/Window Mozilla Window documentation>
-newtype Window = Window { unWindow :: JSVal }
-
-instance Eq (Window) where
-  (Window a) == (Window b) = js_eq a b
-
-instance PToJSVal Window where
-  pToJSVal = unWindow
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal Window where
-  pFromJSVal = Window
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal Window where
-  toJSVal = return . unWindow
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal Window where
-  fromJSVal = return . fmap Window . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsEventTarget Window
-instance IsGObject Window where
-  toGObject = GObject . unWindow
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = Window . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToWindow :: IsGObject obj => obj -> IO Window
-castToWindow = castTo gTypeWindow "Window"
-
-foreign import javascript unsafe "window[\"Window\"]" gTypeWindow :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.WindowBase64".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/WindowBase64 Mozilla WindowBase64 documentation>
-newtype WindowBase64 = WindowBase64 { unWindowBase64 :: JSVal }
-
-instance Eq (WindowBase64) where
-  (WindowBase64 a) == (WindowBase64 b) = js_eq a b
-
-instance PToJSVal WindowBase64 where
-  pToJSVal = unWindowBase64
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal WindowBase64 where
-  pFromJSVal = WindowBase64
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal WindowBase64 where
-  toJSVal = return . unWindowBase64
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal WindowBase64 where
-  fromJSVal = return . fmap WindowBase64 . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject WindowBase64 where
-  toGObject = GObject . unWindowBase64
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = WindowBase64 . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToWindowBase64 :: IsGObject obj => obj -> IO WindowBase64
-castToWindowBase64 = castTo gTypeWindowBase64 "WindowBase64"
-
-foreign import javascript unsafe "window[\"WindowBase64\"]" gTypeWindowBase64 :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.WindowTimers".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/WindowTimers Mozilla WindowTimers documentation>
-newtype WindowTimers = WindowTimers { unWindowTimers :: JSVal }
-
-instance Eq (WindowTimers) where
-  (WindowTimers a) == (WindowTimers b) = js_eq a b
-
-instance PToJSVal WindowTimers where
-  pToJSVal = unWindowTimers
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal WindowTimers where
-  pFromJSVal = WindowTimers
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal WindowTimers where
-  toJSVal = return . unWindowTimers
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal WindowTimers where
-  fromJSVal = return . fmap WindowTimers . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject WindowTimers where
-  toGObject = GObject . unWindowTimers
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = WindowTimers . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToWindowTimers :: IsGObject obj => obj -> IO WindowTimers
-castToWindowTimers = castTo gTypeWindowTimers "WindowTimers"
-
-foreign import javascript unsafe "window[\"WindowTimers\"]" gTypeWindowTimers :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.Worker".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/Worker Mozilla Worker documentation>
-newtype Worker = Worker { unWorker :: JSVal }
-
-instance Eq (Worker) where
-  (Worker a) == (Worker b) = js_eq a b
-
-instance PToJSVal Worker where
-  pToJSVal = unWorker
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal Worker where
-  pFromJSVal = Worker
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal Worker where
-  toJSVal = return . unWorker
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal Worker where
-  fromJSVal = return . fmap Worker . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsEventTarget Worker
-instance IsGObject Worker where
-  toGObject = GObject . unWorker
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = Worker . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToWorker :: IsGObject obj => obj -> IO Worker
-castToWorker = castTo gTypeWorker "Worker"
-
-foreign import javascript unsafe "window[\"Worker\"]" gTypeWorker :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.WorkerGlobalScope".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/WorkerGlobalScope Mozilla WorkerGlobalScope documentation>
-newtype WorkerGlobalScope = WorkerGlobalScope { unWorkerGlobalScope :: JSVal }
-
-instance Eq (WorkerGlobalScope) where
-  (WorkerGlobalScope a) == (WorkerGlobalScope b) = js_eq a b
-
-instance PToJSVal WorkerGlobalScope where
-  pToJSVal = unWorkerGlobalScope
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal WorkerGlobalScope where
-  pFromJSVal = WorkerGlobalScope
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal WorkerGlobalScope where
-  toJSVal = return . unWorkerGlobalScope
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal WorkerGlobalScope where
-  fromJSVal = return . fmap WorkerGlobalScope . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-class IsEventTarget o => IsWorkerGlobalScope o
-toWorkerGlobalScope :: IsWorkerGlobalScope o => o -> WorkerGlobalScope
-toWorkerGlobalScope = unsafeCastGObject . toGObject
-
-instance IsWorkerGlobalScope WorkerGlobalScope
-instance IsEventTarget WorkerGlobalScope
-instance IsGObject WorkerGlobalScope where
-  toGObject = GObject . unWorkerGlobalScope
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = WorkerGlobalScope . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToWorkerGlobalScope :: IsGObject obj => obj -> IO WorkerGlobalScope
-castToWorkerGlobalScope = castTo gTypeWorkerGlobalScope "WorkerGlobalScope"
-
-foreign import javascript unsafe "window[\"WorkerGlobalScope\"]" gTypeWorkerGlobalScope :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.WorkerLocation".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/WorkerLocation Mozilla WorkerLocation documentation>
-newtype WorkerLocation = WorkerLocation { unWorkerLocation :: JSVal }
-
-instance Eq (WorkerLocation) where
-  (WorkerLocation a) == (WorkerLocation b) = js_eq a b
-
-instance PToJSVal WorkerLocation where
-  pToJSVal = unWorkerLocation
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal WorkerLocation where
-  pFromJSVal = WorkerLocation
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal WorkerLocation where
-  toJSVal = return . unWorkerLocation
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal WorkerLocation where
-  fromJSVal = return . fmap WorkerLocation . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject WorkerLocation where
-  toGObject = GObject . unWorkerLocation
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = WorkerLocation . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToWorkerLocation :: IsGObject obj => obj -> IO WorkerLocation
-castToWorkerLocation = castTo gTypeWorkerLocation "WorkerLocation"
-
-foreign import javascript unsafe "window[\"WorkerLocation\"]" gTypeWorkerLocation :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.WorkerNavigator".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/WorkerNavigator Mozilla WorkerNavigator documentation>
-newtype WorkerNavigator = WorkerNavigator { unWorkerNavigator :: JSVal }
-
-instance Eq (WorkerNavigator) where
-  (WorkerNavigator a) == (WorkerNavigator b) = js_eq a b
-
-instance PToJSVal WorkerNavigator where
-  pToJSVal = unWorkerNavigator
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal WorkerNavigator where
-  pFromJSVal = WorkerNavigator
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal WorkerNavigator where
-  toJSVal = return . unWorkerNavigator
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal WorkerNavigator where
-  fromJSVal = return . fmap WorkerNavigator . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject WorkerNavigator where
-  toGObject = GObject . unWorkerNavigator
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = WorkerNavigator . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToWorkerNavigator :: IsGObject obj => obj -> IO WorkerNavigator
-castToWorkerNavigator = castTo gTypeWorkerNavigator "WorkerNavigator"
-
-foreign import javascript unsafe "window[\"WorkerNavigator\"]" gTypeWorkerNavigator :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.XMLHttpRequest".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest Mozilla XMLHttpRequest documentation>
-newtype XMLHttpRequest = XMLHttpRequest { unXMLHttpRequest :: JSVal }
-
-instance Eq (XMLHttpRequest) where
-  (XMLHttpRequest a) == (XMLHttpRequest b) = js_eq a b
-
-instance PToJSVal XMLHttpRequest where
-  pToJSVal = unXMLHttpRequest
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal XMLHttpRequest where
-  pFromJSVal = XMLHttpRequest
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal XMLHttpRequest where
-  toJSVal = return . unXMLHttpRequest
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal XMLHttpRequest where
-  fromJSVal = return . fmap XMLHttpRequest . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsEventTarget XMLHttpRequest
-instance IsGObject XMLHttpRequest where
-  toGObject = GObject . unXMLHttpRequest
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = XMLHttpRequest . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToXMLHttpRequest :: IsGObject obj => obj -> IO XMLHttpRequest
-castToXMLHttpRequest = castTo gTypeXMLHttpRequest "XMLHttpRequest"
-
-foreign import javascript unsafe "window[\"XMLHttpRequest\"]" gTypeXMLHttpRequest :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.XMLHttpRequestProgressEvent".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.ProgressEvent"
---     * "GHCJS.DOM.Event"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequestProgressEvent Mozilla XMLHttpRequestProgressEvent documentation>
-newtype XMLHttpRequestProgressEvent = XMLHttpRequestProgressEvent { unXMLHttpRequestProgressEvent :: JSVal }
-
-instance Eq (XMLHttpRequestProgressEvent) where
-  (XMLHttpRequestProgressEvent a) == (XMLHttpRequestProgressEvent b) = js_eq a b
-
-instance PToJSVal XMLHttpRequestProgressEvent where
-  pToJSVal = unXMLHttpRequestProgressEvent
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal XMLHttpRequestProgressEvent where
-  pFromJSVal = XMLHttpRequestProgressEvent
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal XMLHttpRequestProgressEvent where
-  toJSVal = return . unXMLHttpRequestProgressEvent
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal XMLHttpRequestProgressEvent where
-  fromJSVal = return . fmap XMLHttpRequestProgressEvent . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsProgressEvent XMLHttpRequestProgressEvent
-instance IsEvent XMLHttpRequestProgressEvent
-instance IsGObject XMLHttpRequestProgressEvent where
-  toGObject = GObject . unXMLHttpRequestProgressEvent
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = XMLHttpRequestProgressEvent . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToXMLHttpRequestProgressEvent :: IsGObject obj => obj -> IO XMLHttpRequestProgressEvent
-castToXMLHttpRequestProgressEvent = castTo gTypeXMLHttpRequestProgressEvent "XMLHttpRequestProgressEvent"
-
-foreign import javascript unsafe "window[\"XMLHttpRequestProgressEvent\"]" gTypeXMLHttpRequestProgressEvent :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.XMLHttpRequestUpload".
--- Base interface functions are in:
---
---     * "GHCJS.DOM.EventTarget"
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequestUpload Mozilla XMLHttpRequestUpload documentation>
-newtype XMLHttpRequestUpload = XMLHttpRequestUpload { unXMLHttpRequestUpload :: JSVal }
-
-instance Eq (XMLHttpRequestUpload) where
-  (XMLHttpRequestUpload a) == (XMLHttpRequestUpload b) = js_eq a b
-
-instance PToJSVal XMLHttpRequestUpload where
-  pToJSVal = unXMLHttpRequestUpload
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal XMLHttpRequestUpload where
-  pFromJSVal = XMLHttpRequestUpload
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal XMLHttpRequestUpload where
-  toJSVal = return . unXMLHttpRequestUpload
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal XMLHttpRequestUpload where
-  fromJSVal = return . fmap XMLHttpRequestUpload . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsEventTarget XMLHttpRequestUpload
-instance IsGObject XMLHttpRequestUpload where
-  toGObject = GObject . unXMLHttpRequestUpload
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = XMLHttpRequestUpload . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToXMLHttpRequestUpload :: IsGObject obj => obj -> IO XMLHttpRequestUpload
-castToXMLHttpRequestUpload = castTo gTypeXMLHttpRequestUpload "XMLHttpRequestUpload"
-
-foreign import javascript unsafe "window[\"XMLHttpRequestUpload\"]" gTypeXMLHttpRequestUpload :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.XMLSerializer".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/XMLSerializer Mozilla XMLSerializer documentation>
-newtype XMLSerializer = XMLSerializer { unXMLSerializer :: JSVal }
-
-instance Eq (XMLSerializer) where
-  (XMLSerializer a) == (XMLSerializer b) = js_eq a b
-
-instance PToJSVal XMLSerializer where
-  pToJSVal = unXMLSerializer
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal XMLSerializer where
-  pFromJSVal = XMLSerializer
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal XMLSerializer where
-  toJSVal = return . unXMLSerializer
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal XMLSerializer where
-  fromJSVal = return . fmap XMLSerializer . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject XMLSerializer where
-  toGObject = GObject . unXMLSerializer
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = XMLSerializer . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToXMLSerializer :: IsGObject obj => obj -> IO XMLSerializer
-castToXMLSerializer = castTo gTypeXMLSerializer "XMLSerializer"
-
-foreign import javascript unsafe "window[\"XMLSerializer\"]" gTypeXMLSerializer :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.XPathEvaluator".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/XPathEvaluator Mozilla XPathEvaluator documentation>
-newtype XPathEvaluator = XPathEvaluator { unXPathEvaluator :: JSVal }
-
-instance Eq (XPathEvaluator) where
-  (XPathEvaluator a) == (XPathEvaluator b) = js_eq a b
-
-instance PToJSVal XPathEvaluator where
-  pToJSVal = unXPathEvaluator
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal XPathEvaluator where
-  pFromJSVal = XPathEvaluator
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal XPathEvaluator where
-  toJSVal = return . unXPathEvaluator
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal XPathEvaluator where
-  fromJSVal = return . fmap XPathEvaluator . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject XPathEvaluator where
-  toGObject = GObject . unXPathEvaluator
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = XPathEvaluator . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToXPathEvaluator :: IsGObject obj => obj -> IO XPathEvaluator
-castToXPathEvaluator = castTo gTypeXPathEvaluator "XPathEvaluator"
-
-foreign import javascript unsafe "window[\"XPathEvaluator\"]" gTypeXPathEvaluator :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.XPathExpression".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/XPathExpression Mozilla XPathExpression documentation>
-newtype XPathExpression = XPathExpression { unXPathExpression :: JSVal }
-
-instance Eq (XPathExpression) where
-  (XPathExpression a) == (XPathExpression b) = js_eq a b
-
-instance PToJSVal XPathExpression where
-  pToJSVal = unXPathExpression
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal XPathExpression where
-  pFromJSVal = XPathExpression
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal XPathExpression where
-  toJSVal = return . unXPathExpression
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal XPathExpression where
-  fromJSVal = return . fmap XPathExpression . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject XPathExpression where
-  toGObject = GObject . unXPathExpression
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = XPathExpression . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToXPathExpression :: IsGObject obj => obj -> IO XPathExpression
-castToXPathExpression = castTo gTypeXPathExpression "XPathExpression"
-
-foreign import javascript unsafe "window[\"XPathExpression\"]" gTypeXPathExpression :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.XPathNSResolver".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/XPathNSResolver Mozilla XPathNSResolver documentation>
-newtype XPathNSResolver = XPathNSResolver { unXPathNSResolver :: JSVal }
-
-instance Eq (XPathNSResolver) where
-  (XPathNSResolver a) == (XPathNSResolver b) = js_eq a b
-
-instance PToJSVal XPathNSResolver where
-  pToJSVal = unXPathNSResolver
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal XPathNSResolver where
-  pFromJSVal = XPathNSResolver
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal XPathNSResolver where
-  toJSVal = return . unXPathNSResolver
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal XPathNSResolver where
-  fromJSVal = return . fmap XPathNSResolver . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject XPathNSResolver where
-  toGObject = GObject . unXPathNSResolver
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = XPathNSResolver . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToXPathNSResolver :: IsGObject obj => obj -> IO XPathNSResolver
-castToXPathNSResolver = castTo gTypeXPathNSResolver "XPathNSResolver"
-
-foreign import javascript unsafe "window[\"XPathNSResolver\"]" gTypeXPathNSResolver :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.XPathResult".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/XPathResult Mozilla XPathResult documentation>
-newtype XPathResult = XPathResult { unXPathResult :: JSVal }
-
-instance Eq (XPathResult) where
-  (XPathResult a) == (XPathResult b) = js_eq a b
-
-instance PToJSVal XPathResult where
-  pToJSVal = unXPathResult
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal XPathResult where
-  pFromJSVal = XPathResult
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal XPathResult where
-  toJSVal = return . unXPathResult
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal XPathResult where
-  fromJSVal = return . fmap XPathResult . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject XPathResult where
-  toGObject = GObject . unXPathResult
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = XPathResult . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToXPathResult :: IsGObject obj => obj -> IO XPathResult
-castToXPathResult = castTo gTypeXPathResult "XPathResult"
-
-foreign import javascript unsafe "window[\"XPathResult\"]" gTypeXPathResult :: GType
-
--- | Functions for this inteface are in "GHCJS.DOM.XSLTProcessor".
---
--- <https://developer.mozilla.org/en-US/docs/Web/API/XSLTProcessor Mozilla XSLTProcessor documentation>
-newtype XSLTProcessor = XSLTProcessor { unXSLTProcessor :: JSVal }
-
-instance Eq (XSLTProcessor) where
-  (XSLTProcessor a) == (XSLTProcessor b) = js_eq a b
-
-instance PToJSVal XSLTProcessor where
-  pToJSVal = unXSLTProcessor
-  {-# INLINE pToJSVal #-}
-
-instance PFromJSVal XSLTProcessor where
-  pFromJSVal = XSLTProcessor
-  {-# INLINE pFromJSVal #-}
-
-instance ToJSVal XSLTProcessor where
-  toJSVal = return . unXSLTProcessor
-  {-# INLINE toJSVal #-}
-
-instance FromJSVal XSLTProcessor where
-  fromJSVal = return . fmap XSLTProcessor . maybeJSNullOrUndefined
-  {-# INLINE fromJSVal #-}
-
-instance IsGObject XSLTProcessor where
-  toGObject = GObject . unXSLTProcessor
-  {-# INLINE toGObject #-}
-  unsafeCastGObject = XSLTProcessor . unGObject
-  {-# INLINE unsafeCastGObject #-}
-
-castToXSLTProcessor :: IsGObject obj => obj -> IO XSLTProcessor
-castToXSLTProcessor = castTo gTypeXSLTProcessor "XSLTProcessor"
-
+{-# LANGUAGE CPP, JavaScriptFFI, ForeignFunctionInterface, ConstraintKinds, FlexibleInstances, RankNTypes, FlexibleContexts, ScopedTypeVariables #-}
+-- For HasCallStack compatibility
+{-# LANGUAGE ImplicitParams, KindSignatures #-}
+module GHCJS.DOM.Types (
+
+  -- * JavaScript Context and Monad
+    JSContextRef(..), JSM, askJSM, runJSM, MonadJSM(..), liftJSM
+
+  -- * DOM Context and Monad
+  , DOMContext(..), DOM, askDOM, runDOM, MonadDOM(..), liftDOM
+
+  -- * JavaScript Value
+  , JSVal(..), ToJSVal(..), FromJSVal(..), PToJSVal(..), PFromJSVal(..)
+
+  -- * JavaScript String
+  , JSString(..), ToJSString(..), FromJSString(..)
+  , toJSString, fromJSString, toMaybeJSString, fromMaybeJSString
+
+  -- * Nullable
+  , Nullable(..), nullableToMaybe, maybeToNullable
+
+  -- * DOM String
+  , DOMString(..), ToDOMString(..), FromDOMString(..), IsDOMString
+
+  -- * Object
+  , maybeJSNullOrUndefined, GType(..)
+  , GObject(..), IsGObject, toGObject, gTypeGObject, isA, objectToString
+  , castTo, unsafeCastTo, uncheckedCastTo
+  , js_eq, strictEqual
+
+  -- * Callbacks
+  , AudioBufferCallback(..)
+  , DatabaseCallback(..)
+  , MediaQueryListListener(..)
+  , MediaStreamTrackSourcesCallback(..)
+  , NavigatorUserMediaErrorCallback(..)
+  , NavigatorUserMediaSuccessCallback(..)
+  , NotificationPermissionCallback(..)
+  , PositionCallback(..)
+  , PositionErrorCallback(..)
+  , RequestAnimationFrameCallback(..)
+  , RTCPeerConnectionErrorCallback(..)
+  , RTCSessionDescriptionCallback(..)
+  , RTCStatsCallback(..)
+  , SQLStatementCallback(..)
+  , SQLStatementErrorCallback(..)
+  , SQLTransactionCallback(..)
+  , SQLTransactionErrorCallback(..)
+  , StorageErrorCallback(..)
+  , StorageQuotaCallback(..)
+  , StorageUsageCallback(..)
+  , StringCallback(..)
+  , VoidCallback(..)
+
+  -- * Dictionaries
+  , Dictionary(Dictionary), unDictionary, IsDictionary, toDictionary
+  , BlobPropertyBag(BlobPropertyBag), unBlobPropertyBag, IsBlobPropertyBag, toBlobPropertyBag
+
+  -- * Mutation Callback
+  , MutationCallback(MutationCallback), unMutationCallback, IsMutationCallback, toMutationCallback
+
+  -- * Promise
+  , Promise(Promise), unPromise, IsPromise, toPromise, gTypePromise
+
+  -- * Date
+  , Date(Date), unDate, IsDate, toDate, gTypeDate
+
+  -- * Arrays
+  , Array(Array), unArray, IsArray, toArray, gTypeArray
+  , ObjectArray(ObjectArray), unObjectArray, IsObjectArray, toObjectArray
+  , ArrayBuffer(ArrayBuffer), unArrayBuffer, IsArrayBuffer, toArrayBuffer, gTypeArrayBuffer
+  , ArrayBufferView(ArrayBufferView), unArrayBufferView, IsArrayBufferView, toArrayBufferView
+  , Float32Array(Float32Array), unFloat32Array, IsFloat32Array, toFloat32Array, gTypeFloat32Array
+  , Float64Array(Float64Array), unFloat64Array, IsFloat64Array, toFloat64Array, gTypeFloat64Array
+  , Uint8Array(Uint8Array), unUint8Array, IsUint8Array, toUint8Array, gTypeUint8Array
+  , Uint8ClampedArray(Uint8ClampedArray), unUint8ClampedArray, IsUint8ClampedArray, toUint8ClampedArray, gTypeUint8ClampedArray
+  , Uint16Array(Uint16Array), unUint16Array, IsUint16Array, toUint16Array, gTypeUint16Array
+  , Uint32Array(Uint32Array), unUint32Array, IsUint32Array, toUint32Array, gTypeUint32Array
+  , Int8Array(Int8Array), unInt8Array, IsInt8Array, toInt8Array, gTypeInt8Array
+  , Int16Array(Int16Array), unInt16Array, IsInt16Array, toInt16Array, gTypeInt16Array
+  , Int32Array(Int32Array), unInt32Array, IsInt32Array, toInt32Array, gTypeInt32Array
+
+  -- * Geolocation
+  , SerializedScriptValue(SerializedScriptValue), unSerializedScriptValue, IsSerializedScriptValue, toSerializedScriptValue
+  , PositionOptions(PositionOptions), unPositionOptions, IsPositionOptions, toPositionOptions
+  , Acceleration(Acceleration), unAcceleration, IsAcceleration, toAcceleration
+  , RotationRate(RotationRate), unRotationRate, IsRotationRate, toRotationRate
+
+  -- * Crypto
+  , Algorithm(Algorithm), unAlgorithm, IsAlgorithm, toAlgorithm
+  , CryptoOperationData(CryptoOperationData), unCryptoOperationData, IsCryptoOperationData, toCryptoOperationData
+
+  -- * CanvasStyle (fill & stroke style)
+  , CanvasStyle(CanvasStyle), unCanvasStyle, IsCanvasStyle, toCanvasStyle
+
+  , DOMException(DOMException), unDOMException, IsDOMException, toDOMException
+
+  -- * WebGL typedefs
+  , GLenum(..), GLboolean(..), GLbitfield(..), GLbyte(..), GLshort(..), GLint(..), GLsizei(..)
+  , GLintptr(..), GLsizeiptr(..), GLubyte(..), GLushort(..), GLuint(..), GLfloat(..), GLclampf(..)
+  , GLint64, GLuint64
+
+  -- * Interface types from IDL files
+
+-- AUTO GENERATION STARTS HERE
+  , ANGLEInstancedArrays(ANGLEInstancedArrays), unANGLEInstancedArrays, gTypeANGLEInstancedArrays
+  , AbstractView(AbstractView), unAbstractView, gTypeAbstractView
+  , AbstractWorker(AbstractWorker), unAbstractWorker, gTypeAbstractWorker
+  , AllAudioCapabilities(AllAudioCapabilities), unAllAudioCapabilities, gTypeAllAudioCapabilities
+  , AllVideoCapabilities(AllVideoCapabilities), unAllVideoCapabilities, gTypeAllVideoCapabilities
+  , AnalyserNode(AnalyserNode), unAnalyserNode, gTypeAnalyserNode
+  , AnimationEvent(AnimationEvent), unAnimationEvent, gTypeAnimationEvent
+  , ApplicationCache(ApplicationCache), unApplicationCache, gTypeApplicationCache
+  , Attr(Attr), unAttr, gTypeAttr
+  , AudioBuffer(AudioBuffer), unAudioBuffer, gTypeAudioBuffer
+  , AudioBufferSourceNode(AudioBufferSourceNode), unAudioBufferSourceNode, gTypeAudioBufferSourceNode
+  , AudioContext(AudioContext), unAudioContext, IsAudioContext, toAudioContext, gTypeAudioContext
+  , AudioDestinationNode(AudioDestinationNode), unAudioDestinationNode, gTypeAudioDestinationNode
+  , AudioListener(AudioListener), unAudioListener, gTypeAudioListener
+  , AudioNode(AudioNode), unAudioNode, IsAudioNode, toAudioNode, gTypeAudioNode
+  , AudioParam(AudioParam), unAudioParam, gTypeAudioParam
+  , AudioProcessingEvent(AudioProcessingEvent), unAudioProcessingEvent, gTypeAudioProcessingEvent
+  , AudioStreamTrack(AudioStreamTrack), unAudioStreamTrack, gTypeAudioStreamTrack
+  , AudioTrack(AudioTrack), unAudioTrack, gTypeAudioTrack
+  , AudioTrackList(AudioTrackList), unAudioTrackList, gTypeAudioTrackList
+  , AutocompleteErrorEvent(AutocompleteErrorEvent), unAutocompleteErrorEvent, gTypeAutocompleteErrorEvent
+  , BarProp(BarProp), unBarProp, gTypeBarProp
+  , BatteryManager(BatteryManager), unBatteryManager, gTypeBatteryManager
+  , BeforeLoadEvent(BeforeLoadEvent), unBeforeLoadEvent, gTypeBeforeLoadEvent
+  , BeforeUnloadEvent(BeforeUnloadEvent), unBeforeUnloadEvent, gTypeBeforeUnloadEvent
+  , BiquadFilterNode(BiquadFilterNode), unBiquadFilterNode, gTypeBiquadFilterNode
+  , Blob(Blob), unBlob, IsBlob, toBlob, gTypeBlob
+  , CDATASection(CDATASection), unCDATASection, gTypeCDATASection
+  , CSS(CSS), unCSS, gTypeCSS
+  , CSSCharsetRule(CSSCharsetRule), unCSSCharsetRule, gTypeCSSCharsetRule
+  , CSSFontFaceLoadEvent(CSSFontFaceLoadEvent), unCSSFontFaceLoadEvent, gTypeCSSFontFaceLoadEvent
+  , CSSFontFaceRule(CSSFontFaceRule), unCSSFontFaceRule, gTypeCSSFontFaceRule
+  , CSSImportRule(CSSImportRule), unCSSImportRule, gTypeCSSImportRule
+  , CSSKeyframeRule(CSSKeyframeRule), unCSSKeyframeRule, gTypeCSSKeyframeRule
+  , CSSKeyframesRule(CSSKeyframesRule), unCSSKeyframesRule, gTypeCSSKeyframesRule
+  , CSSMediaRule(CSSMediaRule), unCSSMediaRule, gTypeCSSMediaRule
+  , CSSPageRule(CSSPageRule), unCSSPageRule, gTypeCSSPageRule
+  , CSSPrimitiveValue(CSSPrimitiveValue), unCSSPrimitiveValue, gTypeCSSPrimitiveValue
+  , CSSRule(CSSRule), unCSSRule, IsCSSRule, toCSSRule, gTypeCSSRule
+  , CSSRuleList(CSSRuleList), unCSSRuleList, gTypeCSSRuleList
+  , CSSStyleDeclaration(CSSStyleDeclaration), unCSSStyleDeclaration, gTypeCSSStyleDeclaration
+  , CSSStyleRule(CSSStyleRule), unCSSStyleRule, gTypeCSSStyleRule
+  , CSSStyleSheet(CSSStyleSheet), unCSSStyleSheet, gTypeCSSStyleSheet
+  , CSSSupportsRule(CSSSupportsRule), unCSSSupportsRule, gTypeCSSSupportsRule
+  , CSSUnknownRule(CSSUnknownRule), unCSSUnknownRule, gTypeCSSUnknownRule
+  , CSSValue(CSSValue), unCSSValue, IsCSSValue, toCSSValue, gTypeCSSValue
+  , CSSValueList(CSSValueList), unCSSValueList, IsCSSValueList, toCSSValueList, gTypeCSSValueList
+  , CanvasGradient(CanvasGradient), unCanvasGradient, gTypeCanvasGradient
+  , CanvasPattern(CanvasPattern), unCanvasPattern, gTypeCanvasPattern
+  , CanvasProxy(CanvasProxy), unCanvasProxy, gTypeCanvasProxy
+  , CanvasRenderingContext(CanvasRenderingContext), unCanvasRenderingContext, IsCanvasRenderingContext, toCanvasRenderingContext, gTypeCanvasRenderingContext
+  , CanvasRenderingContext2D(CanvasRenderingContext2D), unCanvasRenderingContext2D, gTypeCanvasRenderingContext2D
+  , CapabilityRange(CapabilityRange), unCapabilityRange, gTypeCapabilityRange
+  , ChannelMergerNode(ChannelMergerNode), unChannelMergerNode, gTypeChannelMergerNode
+  , ChannelSplitterNode(ChannelSplitterNode), unChannelSplitterNode, gTypeChannelSplitterNode
+  , CharacterData(CharacterData), unCharacterData, IsCharacterData, toCharacterData, gTypeCharacterData
+  , ChildNode(ChildNode), unChildNode, gTypeChildNode
+  , ClientRect(ClientRect), unClientRect, gTypeClientRect
+  , ClientRectList(ClientRectList), unClientRectList, gTypeClientRectList
+  , CloseEvent(CloseEvent), unCloseEvent, gTypeCloseEvent
+  , CommandLineAPIHost(CommandLineAPIHost), unCommandLineAPIHost, gTypeCommandLineAPIHost
+  , Comment(Comment), unComment, gTypeComment
+  , CompositionEvent(CompositionEvent), unCompositionEvent, gTypeCompositionEvent
+  , ConvolverNode(ConvolverNode), unConvolverNode, gTypeConvolverNode
+  , Coordinates(Coordinates), unCoordinates, gTypeCoordinates
+  , Counter(Counter), unCounter, gTypeCounter
+  , Crypto(Crypto), unCrypto, gTypeCrypto
+  , CryptoKey(CryptoKey), unCryptoKey, gTypeCryptoKey
+  , CryptoKeyPair(CryptoKeyPair), unCryptoKeyPair, gTypeCryptoKeyPair
+  , CustomEvent(CustomEvent), unCustomEvent, gTypeCustomEvent
+  , DOMError(DOMError), unDOMError, IsDOMError, toDOMError, gTypeDOMError
+  , DOMImplementation(DOMImplementation), unDOMImplementation, gTypeDOMImplementation
+  , DOMNamedFlowCollection(DOMNamedFlowCollection), unDOMNamedFlowCollection, gTypeDOMNamedFlowCollection
+  , DOMParser(DOMParser), unDOMParser, gTypeDOMParser
+  , DOMSettableTokenList(DOMSettableTokenList), unDOMSettableTokenList, gTypeDOMSettableTokenList
+  , DOMStringList(DOMStringList), unDOMStringList, gTypeDOMStringList
+  , DOMStringMap(DOMStringMap), unDOMStringMap, gTypeDOMStringMap
+  , DOMTokenList(DOMTokenList), unDOMTokenList, IsDOMTokenList, toDOMTokenList, gTypeDOMTokenList
+  , DataCue(DataCue), unDataCue, gTypeDataCue
+  , DataTransfer(DataTransfer), unDataTransfer, gTypeDataTransfer
+  , DataTransferItem(DataTransferItem), unDataTransferItem, gTypeDataTransferItem
+  , DataTransferItemList(DataTransferItemList), unDataTransferItemList, gTypeDataTransferItemList
+  , Database(Database), unDatabase, gTypeDatabase
+  , DedicatedWorkerGlobalScope(DedicatedWorkerGlobalScope), unDedicatedWorkerGlobalScope, gTypeDedicatedWorkerGlobalScope
+  , DelayNode(DelayNode), unDelayNode, gTypeDelayNode
+  , DeviceMotionEvent(DeviceMotionEvent), unDeviceMotionEvent, gTypeDeviceMotionEvent
+  , DeviceOrientationEvent(DeviceOrientationEvent), unDeviceOrientationEvent, gTypeDeviceOrientationEvent
+  , DeviceProximityEvent(DeviceProximityEvent), unDeviceProximityEvent, gTypeDeviceProximityEvent
+  , Document(Document), unDocument, IsDocument, toDocument, gTypeDocument
+  , DocumentFragment(DocumentFragment), unDocumentFragment, gTypeDocumentFragment
+  , DocumentType(DocumentType), unDocumentType, gTypeDocumentType
+  , DynamicsCompressorNode(DynamicsCompressorNode), unDynamicsCompressorNode, gTypeDynamicsCompressorNode
+  , EXTBlendMinMax(EXTBlendMinMax), unEXTBlendMinMax, gTypeEXTBlendMinMax
+  , EXTFragDepth(EXTFragDepth), unEXTFragDepth, gTypeEXTFragDepth
+  , EXTShaderTextureLOD(EXTShaderTextureLOD), unEXTShaderTextureLOD, gTypeEXTShaderTextureLOD
+  , EXTTextureFilterAnisotropic(EXTTextureFilterAnisotropic), unEXTTextureFilterAnisotropic, gTypeEXTTextureFilterAnisotropic
+  , EXTsRGB(EXTsRGB), unEXTsRGB, gTypeEXTsRGB
+  , Element(Element), unElement, IsElement, toElement, gTypeElement
+  , Entity(Entity), unEntity, gTypeEntity
+  , EntityReference(EntityReference), unEntityReference, gTypeEntityReference
+  , ErrorEvent(ErrorEvent), unErrorEvent, gTypeErrorEvent
+  , Event(Event), unEvent, IsEvent, toEvent, gTypeEvent
+  , EventListener(EventListener), unEventListener, gTypeEventListener
+  , EventSource(EventSource), unEventSource, gTypeEventSource
+  , EventTarget(EventTarget), unEventTarget, IsEventTarget, toEventTarget, gTypeEventTarget
+  , File(File), unFile, gTypeFile
+  , FileError(FileError), unFileError, gTypeFileError
+  , FileList(FileList), unFileList, gTypeFileList
+  , FileReader(FileReader), unFileReader, gTypeFileReader
+  , FileReaderSync(FileReaderSync), unFileReaderSync, gTypeFileReaderSync
+  , FocusEvent(FocusEvent), unFocusEvent, gTypeFocusEvent
+  , FontLoader(FontLoader), unFontLoader, gTypeFontLoader
+  , FormData(FormData), unFormData, gTypeFormData
+  , GainNode(GainNode), unGainNode, gTypeGainNode
+  , Gamepad(Gamepad), unGamepad, gTypeGamepad
+  , GamepadButton(GamepadButton), unGamepadButton, gTypeGamepadButton
+  , GamepadEvent(GamepadEvent), unGamepadEvent, gTypeGamepadEvent
+  , Geolocation(Geolocation), unGeolocation, gTypeGeolocation
+  , Geoposition(Geoposition), unGeoposition, gTypeGeoposition
+  , HTMLAllCollection(HTMLAllCollection), unHTMLAllCollection, gTypeHTMLAllCollection
+  , HTMLAnchorElement(HTMLAnchorElement), unHTMLAnchorElement, gTypeHTMLAnchorElement
+  , HTMLAppletElement(HTMLAppletElement), unHTMLAppletElement, gTypeHTMLAppletElement
+  , HTMLAreaElement(HTMLAreaElement), unHTMLAreaElement, gTypeHTMLAreaElement
+  , HTMLAudioElement(HTMLAudioElement), unHTMLAudioElement, gTypeHTMLAudioElement
+  , HTMLBRElement(HTMLBRElement), unHTMLBRElement, gTypeHTMLBRElement
+  , HTMLBaseElement(HTMLBaseElement), unHTMLBaseElement, gTypeHTMLBaseElement
+  , HTMLBaseFontElement(HTMLBaseFontElement), unHTMLBaseFontElement, gTypeHTMLBaseFontElement
+  , HTMLBodyElement(HTMLBodyElement), unHTMLBodyElement, gTypeHTMLBodyElement
+  , HTMLButtonElement(HTMLButtonElement), unHTMLButtonElement, gTypeHTMLButtonElement
+  , HTMLCanvasElement(HTMLCanvasElement), unHTMLCanvasElement, gTypeHTMLCanvasElement
+  , HTMLCollection(HTMLCollection), unHTMLCollection, IsHTMLCollection, toHTMLCollection, gTypeHTMLCollection
+  , HTMLDListElement(HTMLDListElement), unHTMLDListElement, gTypeHTMLDListElement
+  , HTMLDataListElement(HTMLDataListElement), unHTMLDataListElement, gTypeHTMLDataListElement
+  , HTMLDetailsElement(HTMLDetailsElement), unHTMLDetailsElement, gTypeHTMLDetailsElement
+  , HTMLDirectoryElement(HTMLDirectoryElement), unHTMLDirectoryElement, gTypeHTMLDirectoryElement
+  , HTMLDivElement(HTMLDivElement), unHTMLDivElement, gTypeHTMLDivElement
+  , HTMLDocument(HTMLDocument), unHTMLDocument, gTypeHTMLDocument
+  , HTMLElement(HTMLElement), unHTMLElement, IsHTMLElement, toHTMLElement, gTypeHTMLElement
+  , HTMLEmbedElement(HTMLEmbedElement), unHTMLEmbedElement, gTypeHTMLEmbedElement
+  , HTMLFieldSetElement(HTMLFieldSetElement), unHTMLFieldSetElement, gTypeHTMLFieldSetElement
+  , HTMLFontElement(HTMLFontElement), unHTMLFontElement, gTypeHTMLFontElement
+  , HTMLFormControlsCollection(HTMLFormControlsCollection), unHTMLFormControlsCollection, gTypeHTMLFormControlsCollection
+  , HTMLFormElement(HTMLFormElement), unHTMLFormElement, gTypeHTMLFormElement
+  , HTMLFrameElement(HTMLFrameElement), unHTMLFrameElement, gTypeHTMLFrameElement
+  , HTMLFrameSetElement(HTMLFrameSetElement), unHTMLFrameSetElement, gTypeHTMLFrameSetElement
+  , HTMLHRElement(HTMLHRElement), unHTMLHRElement, gTypeHTMLHRElement
+  , HTMLHeadElement(HTMLHeadElement), unHTMLHeadElement, gTypeHTMLHeadElement
+  , HTMLHeadingElement(HTMLHeadingElement), unHTMLHeadingElement, gTypeHTMLHeadingElement
+  , HTMLHtmlElement(HTMLHtmlElement), unHTMLHtmlElement, gTypeHTMLHtmlElement
+  , HTMLIFrameElement(HTMLIFrameElement), unHTMLIFrameElement, gTypeHTMLIFrameElement
+  , HTMLImageElement(HTMLImageElement), unHTMLImageElement, gTypeHTMLImageElement
+  , HTMLInputElement(HTMLInputElement), unHTMLInputElement, gTypeHTMLInputElement
+  , HTMLKeygenElement(HTMLKeygenElement), unHTMLKeygenElement, gTypeHTMLKeygenElement
+  , HTMLLIElement(HTMLLIElement), unHTMLLIElement, gTypeHTMLLIElement
+  , HTMLLabelElement(HTMLLabelElement), unHTMLLabelElement, gTypeHTMLLabelElement
+  , HTMLLegendElement(HTMLLegendElement), unHTMLLegendElement, gTypeHTMLLegendElement
+  , HTMLLinkElement(HTMLLinkElement), unHTMLLinkElement, gTypeHTMLLinkElement
+  , HTMLMapElement(HTMLMapElement), unHTMLMapElement, gTypeHTMLMapElement
+  , HTMLMarqueeElement(HTMLMarqueeElement), unHTMLMarqueeElement, gTypeHTMLMarqueeElement
+  , HTMLMediaElement(HTMLMediaElement), unHTMLMediaElement, IsHTMLMediaElement, toHTMLMediaElement, gTypeHTMLMediaElement
+  , HTMLMenuElement(HTMLMenuElement), unHTMLMenuElement, gTypeHTMLMenuElement
+  , HTMLMetaElement(HTMLMetaElement), unHTMLMetaElement, gTypeHTMLMetaElement
+  , HTMLMeterElement(HTMLMeterElement), unHTMLMeterElement, gTypeHTMLMeterElement
+  , HTMLModElement(HTMLModElement), unHTMLModElement, gTypeHTMLModElement
+  , HTMLOListElement(HTMLOListElement), unHTMLOListElement, gTypeHTMLOListElement
+  , HTMLObjectElement(HTMLObjectElement), unHTMLObjectElement, gTypeHTMLObjectElement
+  , HTMLOptGroupElement(HTMLOptGroupElement), unHTMLOptGroupElement, gTypeHTMLOptGroupElement
+  , HTMLOptionElement(HTMLOptionElement), unHTMLOptionElement, gTypeHTMLOptionElement
+  , HTMLOptionsCollection(HTMLOptionsCollection), unHTMLOptionsCollection, gTypeHTMLOptionsCollection
+  , HTMLOutputElement(HTMLOutputElement), unHTMLOutputElement, gTypeHTMLOutputElement
+  , HTMLParagraphElement(HTMLParagraphElement), unHTMLParagraphElement, gTypeHTMLParagraphElement
+  , HTMLParamElement(HTMLParamElement), unHTMLParamElement, gTypeHTMLParamElement
+  , HTMLPreElement(HTMLPreElement), unHTMLPreElement, gTypeHTMLPreElement
+  , HTMLProgressElement(HTMLProgressElement), unHTMLProgressElement, gTypeHTMLProgressElement
+  , HTMLQuoteElement(HTMLQuoteElement), unHTMLQuoteElement, gTypeHTMLQuoteElement
+  , HTMLScriptElement(HTMLScriptElement), unHTMLScriptElement, gTypeHTMLScriptElement
+  , HTMLSelectElement(HTMLSelectElement), unHTMLSelectElement, gTypeHTMLSelectElement
+  , HTMLSourceElement(HTMLSourceElement), unHTMLSourceElement, gTypeHTMLSourceElement
+  , HTMLSpanElement(HTMLSpanElement), unHTMLSpanElement, gTypeHTMLSpanElement
+  , HTMLStyleElement(HTMLStyleElement), unHTMLStyleElement, gTypeHTMLStyleElement
+  , HTMLTableCaptionElement(HTMLTableCaptionElement), unHTMLTableCaptionElement, gTypeHTMLTableCaptionElement
+  , HTMLTableCellElement(HTMLTableCellElement), unHTMLTableCellElement, gTypeHTMLTableCellElement
+  , HTMLTableColElement(HTMLTableColElement), unHTMLTableColElement, gTypeHTMLTableColElement
+  , HTMLTableElement(HTMLTableElement), unHTMLTableElement, gTypeHTMLTableElement
+  , HTMLTableRowElement(HTMLTableRowElement), unHTMLTableRowElement, gTypeHTMLTableRowElement
+  , HTMLTableSectionElement(HTMLTableSectionElement), unHTMLTableSectionElement, gTypeHTMLTableSectionElement
+  , HTMLTemplateElement(HTMLTemplateElement), unHTMLTemplateElement, gTypeHTMLTemplateElement
+  , HTMLTextAreaElement(HTMLTextAreaElement), unHTMLTextAreaElement, gTypeHTMLTextAreaElement
+  , HTMLTitleElement(HTMLTitleElement), unHTMLTitleElement, gTypeHTMLTitleElement
+  , HTMLTrackElement(HTMLTrackElement), unHTMLTrackElement, gTypeHTMLTrackElement
+  , HTMLUListElement(HTMLUListElement), unHTMLUListElement, gTypeHTMLUListElement
+  , HTMLUnknownElement(HTMLUnknownElement), unHTMLUnknownElement, gTypeHTMLUnknownElement
+  , HTMLVideoElement(HTMLVideoElement), unHTMLVideoElement, gTypeHTMLVideoElement
+  , HashChangeEvent(HashChangeEvent), unHashChangeEvent, gTypeHashChangeEvent
+  , History(History), unHistory, gTypeHistory
+  , IDBAny(IDBAny), unIDBAny, gTypeIDBAny
+  , IDBCursor(IDBCursor), unIDBCursor, IsIDBCursor, toIDBCursor, gTypeIDBCursor
+  , IDBCursorWithValue(IDBCursorWithValue), unIDBCursorWithValue, gTypeIDBCursorWithValue
+  , IDBDatabase(IDBDatabase), unIDBDatabase, gTypeIDBDatabase
+  , IDBFactory(IDBFactory), unIDBFactory, gTypeIDBFactory
+  , IDBIndex(IDBIndex), unIDBIndex, gTypeIDBIndex
+  , IDBKeyRange(IDBKeyRange), unIDBKeyRange, gTypeIDBKeyRange
+  , IDBObjectStore(IDBObjectStore), unIDBObjectStore, gTypeIDBObjectStore
+  , IDBOpenDBRequest(IDBOpenDBRequest), unIDBOpenDBRequest, gTypeIDBOpenDBRequest
+  , IDBRequest(IDBRequest), unIDBRequest, IsIDBRequest, toIDBRequest, gTypeIDBRequest
+  , IDBTransaction(IDBTransaction), unIDBTransaction, gTypeIDBTransaction
+  , IDBVersionChangeEvent(IDBVersionChangeEvent), unIDBVersionChangeEvent, gTypeIDBVersionChangeEvent
+  , ImageData(ImageData), unImageData, gTypeImageData
+  , InspectorFrontendHost(InspectorFrontendHost), unInspectorFrontendHost, gTypeInspectorFrontendHost
+  , InternalSettings(InternalSettings), unInternalSettings, gTypeInternalSettings
+  , Internals(Internals), unInternals, gTypeInternals
+  , KeyboardEvent(KeyboardEvent), unKeyboardEvent, gTypeKeyboardEvent
+  , Location(Location), unLocation, gTypeLocation
+  , MallocStatistics(MallocStatistics), unMallocStatistics, gTypeMallocStatistics
+  , MediaController(MediaController), unMediaController, gTypeMediaController
+  , MediaControlsHost(MediaControlsHost), unMediaControlsHost, gTypeMediaControlsHost
+  , MediaElementAudioSourceNode(MediaElementAudioSourceNode), unMediaElementAudioSourceNode, gTypeMediaElementAudioSourceNode
+  , MediaError(MediaError), unMediaError, gTypeMediaError
+  , MediaKeyError(MediaKeyError), unMediaKeyError, gTypeMediaKeyError
+  , MediaKeyEvent(MediaKeyEvent), unMediaKeyEvent, gTypeMediaKeyEvent
+  , MediaKeyMessageEvent(MediaKeyMessageEvent), unMediaKeyMessageEvent, gTypeMediaKeyMessageEvent
+  , MediaKeyNeededEvent(MediaKeyNeededEvent), unMediaKeyNeededEvent, gTypeMediaKeyNeededEvent
+  , MediaKeySession(MediaKeySession), unMediaKeySession, gTypeMediaKeySession
+  , MediaKeys(MediaKeys), unMediaKeys, gTypeMediaKeys
+  , MediaList(MediaList), unMediaList, gTypeMediaList
+  , MediaQueryList(MediaQueryList), unMediaQueryList, gTypeMediaQueryList
+  , MediaSource(MediaSource), unMediaSource, gTypeMediaSource
+  , MediaSourceStates(MediaSourceStates), unMediaSourceStates, gTypeMediaSourceStates
+  , MediaStream(MediaStream), unMediaStream, gTypeMediaStream
+  , MediaStreamAudioDestinationNode(MediaStreamAudioDestinationNode), unMediaStreamAudioDestinationNode, gTypeMediaStreamAudioDestinationNode
+  , MediaStreamAudioSourceNode(MediaStreamAudioSourceNode), unMediaStreamAudioSourceNode, gTypeMediaStreamAudioSourceNode
+  , MediaStreamCapabilities(MediaStreamCapabilities), unMediaStreamCapabilities, IsMediaStreamCapabilities, toMediaStreamCapabilities, gTypeMediaStreamCapabilities
+  , MediaStreamEvent(MediaStreamEvent), unMediaStreamEvent, gTypeMediaStreamEvent
+  , MediaStreamTrack(MediaStreamTrack), unMediaStreamTrack, IsMediaStreamTrack, toMediaStreamTrack, gTypeMediaStreamTrack
+  , MediaStreamTrackEvent(MediaStreamTrackEvent), unMediaStreamTrackEvent, gTypeMediaStreamTrackEvent
+  , MediaTrackConstraint(MediaTrackConstraint), unMediaTrackConstraint, gTypeMediaTrackConstraint
+  , MediaTrackConstraintSet(MediaTrackConstraintSet), unMediaTrackConstraintSet, gTypeMediaTrackConstraintSet
+  , MediaTrackConstraints(MediaTrackConstraints), unMediaTrackConstraints, gTypeMediaTrackConstraints
+  , MemoryInfo(MemoryInfo), unMemoryInfo, gTypeMemoryInfo
+  , MessageChannel(MessageChannel), unMessageChannel, gTypeMessageChannel
+  , MessageEvent(MessageEvent), unMessageEvent, gTypeMessageEvent
+  , MessagePort(MessagePort), unMessagePort, gTypeMessagePort
+  , MimeType(MimeType), unMimeType, gTypeMimeType
+  , MimeTypeArray(MimeTypeArray), unMimeTypeArray, gTypeMimeTypeArray
+  , MouseEvent(MouseEvent), unMouseEvent, IsMouseEvent, toMouseEvent, gTypeMouseEvent
+  , MutationEvent(MutationEvent), unMutationEvent, gTypeMutationEvent
+  , MutationObserver(MutationObserver), unMutationObserver, gTypeMutationObserver
+  , MutationRecord(MutationRecord), unMutationRecord, gTypeMutationRecord
+  , NamedNodeMap(NamedNodeMap), unNamedNodeMap, gTypeNamedNodeMap
+  , Navigator(Navigator), unNavigator, gTypeNavigator
+  , NavigatorUserMediaError(NavigatorUserMediaError), unNavigatorUserMediaError, gTypeNavigatorUserMediaError
+  , Node(Node), unNode, IsNode, toNode, gTypeNode
+  , NodeFilter(NodeFilter), unNodeFilter, gTypeNodeFilter
+  , NodeIterator(NodeIterator), unNodeIterator, gTypeNodeIterator
+  , NodeList(NodeList), unNodeList, IsNodeList, toNodeList, gTypeNodeList
+  , Notification(Notification), unNotification, gTypeNotification
+  , NotificationCenter(NotificationCenter), unNotificationCenter, gTypeNotificationCenter
+  , OESElementIndexUint(OESElementIndexUint), unOESElementIndexUint, gTypeOESElementIndexUint
+  , OESStandardDerivatives(OESStandardDerivatives), unOESStandardDerivatives, gTypeOESStandardDerivatives
+  , OESTextureFloat(OESTextureFloat), unOESTextureFloat, gTypeOESTextureFloat
+  , OESTextureFloatLinear(OESTextureFloatLinear), unOESTextureFloatLinear, gTypeOESTextureFloatLinear
+  , OESTextureHalfFloat(OESTextureHalfFloat), unOESTextureHalfFloat, gTypeOESTextureHalfFloat
+  , OESTextureHalfFloatLinear(OESTextureHalfFloatLinear), unOESTextureHalfFloatLinear, gTypeOESTextureHalfFloatLinear
+  , OESVertexArrayObject(OESVertexArrayObject), unOESVertexArrayObject, gTypeOESVertexArrayObject
+  , OfflineAudioCompletionEvent(OfflineAudioCompletionEvent), unOfflineAudioCompletionEvent, gTypeOfflineAudioCompletionEvent
+  , OfflineAudioContext(OfflineAudioContext), unOfflineAudioContext, gTypeOfflineAudioContext
+  , OscillatorNode(OscillatorNode), unOscillatorNode, gTypeOscillatorNode
+  , OverflowEvent(OverflowEvent), unOverflowEvent, gTypeOverflowEvent
+  , PageTransitionEvent(PageTransitionEvent), unPageTransitionEvent, gTypePageTransitionEvent
+  , PannerNode(PannerNode), unPannerNode, gTypePannerNode
+  , Path2D(Path2D), unPath2D, gTypePath2D
+  , Performance(Performance), unPerformance, gTypePerformance
+  , PerformanceEntry(PerformanceEntry), unPerformanceEntry, IsPerformanceEntry, toPerformanceEntry, gTypePerformanceEntry
+  , PerformanceEntryList(PerformanceEntryList), unPerformanceEntryList, gTypePerformanceEntryList
+  , PerformanceMark(PerformanceMark), unPerformanceMark, gTypePerformanceMark
+  , PerformanceMeasure(PerformanceMeasure), unPerformanceMeasure, gTypePerformanceMeasure
+  , PerformanceNavigation(PerformanceNavigation), unPerformanceNavigation, gTypePerformanceNavigation
+  , PerformanceResourceTiming(PerformanceResourceTiming), unPerformanceResourceTiming, gTypePerformanceResourceTiming
+  , PerformanceTiming(PerformanceTiming), unPerformanceTiming, gTypePerformanceTiming
+  , PeriodicWave(PeriodicWave), unPeriodicWave, gTypePeriodicWave
+  , Plugin(Plugin), unPlugin, gTypePlugin
+  , PluginArray(PluginArray), unPluginArray, gTypePluginArray
+  , PopStateEvent(PopStateEvent), unPopStateEvent, gTypePopStateEvent
+  , PositionError(PositionError), unPositionError, gTypePositionError
+  , ProcessingInstruction(ProcessingInstruction), unProcessingInstruction, gTypeProcessingInstruction
+  , ProgressEvent(ProgressEvent), unProgressEvent, IsProgressEvent, toProgressEvent, gTypeProgressEvent
+  , QuickTimePluginReplacement(QuickTimePluginReplacement), unQuickTimePluginReplacement, gTypeQuickTimePluginReplacement
+  , RGBColor(RGBColor), unRGBColor, gTypeRGBColor
+  , RTCConfiguration(RTCConfiguration), unRTCConfiguration, gTypeRTCConfiguration
+  , RTCDTMFSender(RTCDTMFSender), unRTCDTMFSender, gTypeRTCDTMFSender
+  , RTCDTMFToneChangeEvent(RTCDTMFToneChangeEvent), unRTCDTMFToneChangeEvent, gTypeRTCDTMFToneChangeEvent
+  , RTCDataChannel(RTCDataChannel), unRTCDataChannel, gTypeRTCDataChannel
+  , RTCDataChannelEvent(RTCDataChannelEvent), unRTCDataChannelEvent, gTypeRTCDataChannelEvent
+  , RTCIceCandidate(RTCIceCandidate), unRTCIceCandidate, gTypeRTCIceCandidate
+  , RTCIceCandidateEvent(RTCIceCandidateEvent), unRTCIceCandidateEvent, gTypeRTCIceCandidateEvent
+  , RTCIceServer(RTCIceServer), unRTCIceServer, gTypeRTCIceServer
+  , RTCPeerConnection(RTCPeerConnection), unRTCPeerConnection, gTypeRTCPeerConnection
+  , RTCSessionDescription(RTCSessionDescription), unRTCSessionDescription, gTypeRTCSessionDescription
+  , RTCStatsReport(RTCStatsReport), unRTCStatsReport, gTypeRTCStatsReport
+  , RTCStatsResponse(RTCStatsResponse), unRTCStatsResponse, gTypeRTCStatsResponse
+  , RadioNodeList(RadioNodeList), unRadioNodeList, gTypeRadioNodeList
+  , Range(Range), unRange, gTypeRange
+  , ReadableStream(ReadableStream), unReadableStream, gTypeReadableStream
+  , Rect(Rect), unRect, gTypeRect
+  , SQLError(SQLError), unSQLError, gTypeSQLError
+  , SQLResultSet(SQLResultSet), unSQLResultSet, gTypeSQLResultSet
+  , SQLResultSetRowList(SQLResultSetRowList), unSQLResultSetRowList, gTypeSQLResultSetRowList
+  , SQLTransaction(SQLTransaction), unSQLTransaction, gTypeSQLTransaction
+  , SVGAElement(SVGAElement), unSVGAElement, gTypeSVGAElement
+  , SVGAltGlyphDefElement(SVGAltGlyphDefElement), unSVGAltGlyphDefElement, gTypeSVGAltGlyphDefElement
+  , SVGAltGlyphElement(SVGAltGlyphElement), unSVGAltGlyphElement, gTypeSVGAltGlyphElement
+  , SVGAltGlyphItemElement(SVGAltGlyphItemElement), unSVGAltGlyphItemElement, gTypeSVGAltGlyphItemElement
+  , SVGAngle(SVGAngle), unSVGAngle, gTypeSVGAngle
+  , SVGAnimateColorElement(SVGAnimateColorElement), unSVGAnimateColorElement, gTypeSVGAnimateColorElement
+  , SVGAnimateElement(SVGAnimateElement), unSVGAnimateElement, gTypeSVGAnimateElement
+  , SVGAnimateMotionElement(SVGAnimateMotionElement), unSVGAnimateMotionElement, gTypeSVGAnimateMotionElement
+  , SVGAnimateTransformElement(SVGAnimateTransformElement), unSVGAnimateTransformElement, gTypeSVGAnimateTransformElement
+  , SVGAnimatedAngle(SVGAnimatedAngle), unSVGAnimatedAngle, gTypeSVGAnimatedAngle
+  , SVGAnimatedBoolean(SVGAnimatedBoolean), unSVGAnimatedBoolean, gTypeSVGAnimatedBoolean
+  , SVGAnimatedEnumeration(SVGAnimatedEnumeration), unSVGAnimatedEnumeration, gTypeSVGAnimatedEnumeration
+  , SVGAnimatedInteger(SVGAnimatedInteger), unSVGAnimatedInteger, gTypeSVGAnimatedInteger
+  , SVGAnimatedLength(SVGAnimatedLength), unSVGAnimatedLength, gTypeSVGAnimatedLength
+  , SVGAnimatedLengthList(SVGAnimatedLengthList), unSVGAnimatedLengthList, gTypeSVGAnimatedLengthList
+  , SVGAnimatedNumber(SVGAnimatedNumber), unSVGAnimatedNumber, gTypeSVGAnimatedNumber
+  , SVGAnimatedNumberList(SVGAnimatedNumberList), unSVGAnimatedNumberList, gTypeSVGAnimatedNumberList
+  , SVGAnimatedPreserveAspectRatio(SVGAnimatedPreserveAspectRatio), unSVGAnimatedPreserveAspectRatio, gTypeSVGAnimatedPreserveAspectRatio
+  , SVGAnimatedRect(SVGAnimatedRect), unSVGAnimatedRect, gTypeSVGAnimatedRect
+  , SVGAnimatedString(SVGAnimatedString), unSVGAnimatedString, gTypeSVGAnimatedString
+  , SVGAnimatedTransformList(SVGAnimatedTransformList), unSVGAnimatedTransformList, gTypeSVGAnimatedTransformList
+  , SVGAnimationElement(SVGAnimationElement), unSVGAnimationElement, IsSVGAnimationElement, toSVGAnimationElement, gTypeSVGAnimationElement
+  , SVGCircleElement(SVGCircleElement), unSVGCircleElement, gTypeSVGCircleElement
+  , SVGClipPathElement(SVGClipPathElement), unSVGClipPathElement, gTypeSVGClipPathElement
+  , SVGColor(SVGColor), unSVGColor, IsSVGColor, toSVGColor, gTypeSVGColor
+  , SVGComponentTransferFunctionElement(SVGComponentTransferFunctionElement), unSVGComponentTransferFunctionElement, IsSVGComponentTransferFunctionElement, toSVGComponentTransferFunctionElement, gTypeSVGComponentTransferFunctionElement
+  , SVGCursorElement(SVGCursorElement), unSVGCursorElement, gTypeSVGCursorElement
+  , SVGDefsElement(SVGDefsElement), unSVGDefsElement, gTypeSVGDefsElement
+  , SVGDescElement(SVGDescElement), unSVGDescElement, gTypeSVGDescElement
+  , SVGDocument(SVGDocument), unSVGDocument, gTypeSVGDocument
+  , SVGElement(SVGElement), unSVGElement, IsSVGElement, toSVGElement, gTypeSVGElement
+  , SVGEllipseElement(SVGEllipseElement), unSVGEllipseElement, gTypeSVGEllipseElement
+  , SVGExternalResourcesRequired(SVGExternalResourcesRequired), unSVGExternalResourcesRequired, gTypeSVGExternalResourcesRequired
+  , SVGFEBlendElement(SVGFEBlendElement), unSVGFEBlendElement, gTypeSVGFEBlendElement
+  , SVGFEColorMatrixElement(SVGFEColorMatrixElement), unSVGFEColorMatrixElement, gTypeSVGFEColorMatrixElement
+  , SVGFEComponentTransferElement(SVGFEComponentTransferElement), unSVGFEComponentTransferElement, gTypeSVGFEComponentTransferElement
+  , SVGFECompositeElement(SVGFECompositeElement), unSVGFECompositeElement, gTypeSVGFECompositeElement
+  , SVGFEConvolveMatrixElement(SVGFEConvolveMatrixElement), unSVGFEConvolveMatrixElement, gTypeSVGFEConvolveMatrixElement
+  , SVGFEDiffuseLightingElement(SVGFEDiffuseLightingElement), unSVGFEDiffuseLightingElement, gTypeSVGFEDiffuseLightingElement
+  , SVGFEDisplacementMapElement(SVGFEDisplacementMapElement), unSVGFEDisplacementMapElement, gTypeSVGFEDisplacementMapElement
+  , SVGFEDistantLightElement(SVGFEDistantLightElement), unSVGFEDistantLightElement, gTypeSVGFEDistantLightElement
+  , SVGFEDropShadowElement(SVGFEDropShadowElement), unSVGFEDropShadowElement, gTypeSVGFEDropShadowElement
+  , SVGFEFloodElement(SVGFEFloodElement), unSVGFEFloodElement, gTypeSVGFEFloodElement
+  , SVGFEFuncAElement(SVGFEFuncAElement), unSVGFEFuncAElement, gTypeSVGFEFuncAElement
+  , SVGFEFuncBElement(SVGFEFuncBElement), unSVGFEFuncBElement, gTypeSVGFEFuncBElement
+  , SVGFEFuncGElement(SVGFEFuncGElement), unSVGFEFuncGElement, gTypeSVGFEFuncGElement
+  , SVGFEFuncRElement(SVGFEFuncRElement), unSVGFEFuncRElement, gTypeSVGFEFuncRElement
+  , SVGFEGaussianBlurElement(SVGFEGaussianBlurElement), unSVGFEGaussianBlurElement, gTypeSVGFEGaussianBlurElement
+  , SVGFEImageElement(SVGFEImageElement), unSVGFEImageElement, gTypeSVGFEImageElement
+  , SVGFEMergeElement(SVGFEMergeElement), unSVGFEMergeElement, gTypeSVGFEMergeElement
+  , SVGFEMergeNodeElement(SVGFEMergeNodeElement), unSVGFEMergeNodeElement, gTypeSVGFEMergeNodeElement
+  , SVGFEMorphologyElement(SVGFEMorphologyElement), unSVGFEMorphologyElement, gTypeSVGFEMorphologyElement
+  , SVGFEOffsetElement(SVGFEOffsetElement), unSVGFEOffsetElement, gTypeSVGFEOffsetElement
+  , SVGFEPointLightElement(SVGFEPointLightElement), unSVGFEPointLightElement, gTypeSVGFEPointLightElement
+  , SVGFESpecularLightingElement(SVGFESpecularLightingElement), unSVGFESpecularLightingElement, gTypeSVGFESpecularLightingElement
+  , SVGFESpotLightElement(SVGFESpotLightElement), unSVGFESpotLightElement, gTypeSVGFESpotLightElement
+  , SVGFETileElement(SVGFETileElement), unSVGFETileElement, gTypeSVGFETileElement
+  , SVGFETurbulenceElement(SVGFETurbulenceElement), unSVGFETurbulenceElement, gTypeSVGFETurbulenceElement
+  , SVGFilterElement(SVGFilterElement), unSVGFilterElement, gTypeSVGFilterElement
+  , SVGFilterPrimitiveStandardAttributes(SVGFilterPrimitiveStandardAttributes), unSVGFilterPrimitiveStandardAttributes, gTypeSVGFilterPrimitiveStandardAttributes
+  , SVGFitToViewBox(SVGFitToViewBox), unSVGFitToViewBox, gTypeSVGFitToViewBox
+  , SVGFontElement(SVGFontElement), unSVGFontElement, gTypeSVGFontElement
+  , SVGFontFaceElement(SVGFontFaceElement), unSVGFontFaceElement, gTypeSVGFontFaceElement
+  , SVGFontFaceFormatElement(SVGFontFaceFormatElement), unSVGFontFaceFormatElement, gTypeSVGFontFaceFormatElement
+  , SVGFontFaceNameElement(SVGFontFaceNameElement), unSVGFontFaceNameElement, gTypeSVGFontFaceNameElement
+  , SVGFontFaceSrcElement(SVGFontFaceSrcElement), unSVGFontFaceSrcElement, gTypeSVGFontFaceSrcElement
+  , SVGFontFaceUriElement(SVGFontFaceUriElement), unSVGFontFaceUriElement, gTypeSVGFontFaceUriElement
+  , SVGForeignObjectElement(SVGForeignObjectElement), unSVGForeignObjectElement, gTypeSVGForeignObjectElement
+  , SVGGElement(SVGGElement), unSVGGElement, gTypeSVGGElement
+  , SVGGlyphElement(SVGGlyphElement), unSVGGlyphElement, gTypeSVGGlyphElement
+  , SVGGlyphRefElement(SVGGlyphRefElement), unSVGGlyphRefElement, gTypeSVGGlyphRefElement
+  , SVGGradientElement(SVGGradientElement), unSVGGradientElement, IsSVGGradientElement, toSVGGradientElement, gTypeSVGGradientElement
+  , SVGGraphicsElement(SVGGraphicsElement), unSVGGraphicsElement, IsSVGGraphicsElement, toSVGGraphicsElement, gTypeSVGGraphicsElement
+  , SVGHKernElement(SVGHKernElement), unSVGHKernElement, gTypeSVGHKernElement
+  , SVGImageElement(SVGImageElement), unSVGImageElement, gTypeSVGImageElement
+  , SVGLength(SVGLength), unSVGLength, gTypeSVGLength
+  , SVGLengthList(SVGLengthList), unSVGLengthList, gTypeSVGLengthList
+  , SVGLineElement(SVGLineElement), unSVGLineElement, gTypeSVGLineElement
+  , SVGLinearGradientElement(SVGLinearGradientElement), unSVGLinearGradientElement, gTypeSVGLinearGradientElement
+  , SVGMPathElement(SVGMPathElement), unSVGMPathElement, gTypeSVGMPathElement
+  , SVGMarkerElement(SVGMarkerElement), unSVGMarkerElement, gTypeSVGMarkerElement
+  , SVGMaskElement(SVGMaskElement), unSVGMaskElement, gTypeSVGMaskElement
+  , SVGMatrix(SVGMatrix), unSVGMatrix, gTypeSVGMatrix
+  , SVGMetadataElement(SVGMetadataElement), unSVGMetadataElement, gTypeSVGMetadataElement
+  , SVGMissingGlyphElement(SVGMissingGlyphElement), unSVGMissingGlyphElement, gTypeSVGMissingGlyphElement
+  , SVGNumber(SVGNumber), unSVGNumber, gTypeSVGNumber
+  , SVGNumberList(SVGNumberList), unSVGNumberList, gTypeSVGNumberList
+  , SVGPaint(SVGPaint), unSVGPaint, gTypeSVGPaint
+  , SVGPathElement(SVGPathElement), unSVGPathElement, gTypeSVGPathElement
+  , SVGPathSeg(SVGPathSeg), unSVGPathSeg, IsSVGPathSeg, toSVGPathSeg, gTypeSVGPathSeg
+  , SVGPathSegArcAbs(SVGPathSegArcAbs), unSVGPathSegArcAbs, gTypeSVGPathSegArcAbs
+  , SVGPathSegArcRel(SVGPathSegArcRel), unSVGPathSegArcRel, gTypeSVGPathSegArcRel
+  , SVGPathSegClosePath(SVGPathSegClosePath), unSVGPathSegClosePath, gTypeSVGPathSegClosePath
+  , SVGPathSegCurvetoCubicAbs(SVGPathSegCurvetoCubicAbs), unSVGPathSegCurvetoCubicAbs, gTypeSVGPathSegCurvetoCubicAbs
+  , SVGPathSegCurvetoCubicRel(SVGPathSegCurvetoCubicRel), unSVGPathSegCurvetoCubicRel, gTypeSVGPathSegCurvetoCubicRel
+  , SVGPathSegCurvetoCubicSmoothAbs(SVGPathSegCurvetoCubicSmoothAbs), unSVGPathSegCurvetoCubicSmoothAbs, gTypeSVGPathSegCurvetoCubicSmoothAbs
+  , SVGPathSegCurvetoCubicSmoothRel(SVGPathSegCurvetoCubicSmoothRel), unSVGPathSegCurvetoCubicSmoothRel, gTypeSVGPathSegCurvetoCubicSmoothRel
+  , SVGPathSegCurvetoQuadraticAbs(SVGPathSegCurvetoQuadraticAbs), unSVGPathSegCurvetoQuadraticAbs, gTypeSVGPathSegCurvetoQuadraticAbs
+  , SVGPathSegCurvetoQuadraticRel(SVGPathSegCurvetoQuadraticRel), unSVGPathSegCurvetoQuadraticRel, gTypeSVGPathSegCurvetoQuadraticRel
+  , SVGPathSegCurvetoQuadraticSmoothAbs(SVGPathSegCurvetoQuadraticSmoothAbs), unSVGPathSegCurvetoQuadraticSmoothAbs, gTypeSVGPathSegCurvetoQuadraticSmoothAbs
+  , SVGPathSegCurvetoQuadraticSmoothRel(SVGPathSegCurvetoQuadraticSmoothRel), unSVGPathSegCurvetoQuadraticSmoothRel, gTypeSVGPathSegCurvetoQuadraticSmoothRel
+  , SVGPathSegLinetoAbs(SVGPathSegLinetoAbs), unSVGPathSegLinetoAbs, gTypeSVGPathSegLinetoAbs
+  , SVGPathSegLinetoHorizontalAbs(SVGPathSegLinetoHorizontalAbs), unSVGPathSegLinetoHorizontalAbs, gTypeSVGPathSegLinetoHorizontalAbs
+  , SVGPathSegLinetoHorizontalRel(SVGPathSegLinetoHorizontalRel), unSVGPathSegLinetoHorizontalRel, gTypeSVGPathSegLinetoHorizontalRel
+  , SVGPathSegLinetoRel(SVGPathSegLinetoRel), unSVGPathSegLinetoRel, gTypeSVGPathSegLinetoRel
+  , SVGPathSegLinetoVerticalAbs(SVGPathSegLinetoVerticalAbs), unSVGPathSegLinetoVerticalAbs, gTypeSVGPathSegLinetoVerticalAbs
+  , SVGPathSegLinetoVerticalRel(SVGPathSegLinetoVerticalRel), unSVGPathSegLinetoVerticalRel, gTypeSVGPathSegLinetoVerticalRel
+  , SVGPathSegList(SVGPathSegList), unSVGPathSegList, gTypeSVGPathSegList
+  , SVGPathSegMovetoAbs(SVGPathSegMovetoAbs), unSVGPathSegMovetoAbs, gTypeSVGPathSegMovetoAbs
+  , SVGPathSegMovetoRel(SVGPathSegMovetoRel), unSVGPathSegMovetoRel, gTypeSVGPathSegMovetoRel
+  , SVGPatternElement(SVGPatternElement), unSVGPatternElement, gTypeSVGPatternElement
+  , SVGPoint(SVGPoint), unSVGPoint, gTypeSVGPoint
+  , SVGPointList(SVGPointList), unSVGPointList, gTypeSVGPointList
+  , SVGPolygonElement(SVGPolygonElement), unSVGPolygonElement, gTypeSVGPolygonElement
+  , SVGPolylineElement(SVGPolylineElement), unSVGPolylineElement, gTypeSVGPolylineElement
+  , SVGPreserveAspectRatio(SVGPreserveAspectRatio), unSVGPreserveAspectRatio, gTypeSVGPreserveAspectRatio
+  , SVGRadialGradientElement(SVGRadialGradientElement), unSVGRadialGradientElement, gTypeSVGRadialGradientElement
+  , SVGRect(SVGRect), unSVGRect, gTypeSVGRect
+  , SVGRectElement(SVGRectElement), unSVGRectElement, gTypeSVGRectElement
+  , SVGRenderingIntent(SVGRenderingIntent), unSVGRenderingIntent, gTypeSVGRenderingIntent
+  , SVGSVGElement(SVGSVGElement), unSVGSVGElement, gTypeSVGSVGElement
+  , SVGScriptElement(SVGScriptElement), unSVGScriptElement, gTypeSVGScriptElement
+  , SVGSetElement(SVGSetElement), unSVGSetElement, gTypeSVGSetElement
+  , SVGStopElement(SVGStopElement), unSVGStopElement, gTypeSVGStopElement
+  , SVGStringList(SVGStringList), unSVGStringList, gTypeSVGStringList
+  , SVGStyleElement(SVGStyleElement), unSVGStyleElement, gTypeSVGStyleElement
+  , SVGSwitchElement(SVGSwitchElement), unSVGSwitchElement, gTypeSVGSwitchElement
+  , SVGSymbolElement(SVGSymbolElement), unSVGSymbolElement, gTypeSVGSymbolElement
+  , SVGTRefElement(SVGTRefElement), unSVGTRefElement, gTypeSVGTRefElement
+  , SVGTSpanElement(SVGTSpanElement), unSVGTSpanElement, gTypeSVGTSpanElement
+  , SVGTests(SVGTests), unSVGTests, gTypeSVGTests
+  , SVGTextContentElement(SVGTextContentElement), unSVGTextContentElement, IsSVGTextContentElement, toSVGTextContentElement, gTypeSVGTextContentElement
+  , SVGTextElement(SVGTextElement), unSVGTextElement, gTypeSVGTextElement
+  , SVGTextPathElement(SVGTextPathElement), unSVGTextPathElement, gTypeSVGTextPathElement
+  , SVGTextPositioningElement(SVGTextPositioningElement), unSVGTextPositioningElement, IsSVGTextPositioningElement, toSVGTextPositioningElement, gTypeSVGTextPositioningElement
+  , SVGTitleElement(SVGTitleElement), unSVGTitleElement, gTypeSVGTitleElement
+  , SVGTransform(SVGTransform), unSVGTransform, gTypeSVGTransform
+  , SVGTransformList(SVGTransformList), unSVGTransformList, gTypeSVGTransformList
+  , SVGURIReference(SVGURIReference), unSVGURIReference, gTypeSVGURIReference
+  , SVGUnitTypes(SVGUnitTypes), unSVGUnitTypes, gTypeSVGUnitTypes
+  , SVGUseElement(SVGUseElement), unSVGUseElement, gTypeSVGUseElement
+  , SVGVKernElement(SVGVKernElement), unSVGVKernElement, gTypeSVGVKernElement
+  , SVGViewElement(SVGViewElement), unSVGViewElement, gTypeSVGViewElement
+  , SVGViewSpec(SVGViewSpec), unSVGViewSpec, gTypeSVGViewSpec
+  , SVGZoomAndPan(SVGZoomAndPan), unSVGZoomAndPan, gTypeSVGZoomAndPan
+  , SVGZoomEvent(SVGZoomEvent), unSVGZoomEvent, gTypeSVGZoomEvent
+  , Screen(Screen), unScreen, gTypeScreen
+  , ScriptProcessorNode(ScriptProcessorNode), unScriptProcessorNode, gTypeScriptProcessorNode
+  , ScriptProfile(ScriptProfile), unScriptProfile, gTypeScriptProfile
+  , ScriptProfileNode(ScriptProfileNode), unScriptProfileNode, gTypeScriptProfileNode
+  , SecurityPolicy(SecurityPolicy), unSecurityPolicy, gTypeSecurityPolicy
+  , SecurityPolicyViolationEvent(SecurityPolicyViolationEvent), unSecurityPolicyViolationEvent, gTypeSecurityPolicyViolationEvent
+  , Selection(Selection), unSelection, gTypeSelection
+  , SourceBuffer(SourceBuffer), unSourceBuffer, gTypeSourceBuffer
+  , SourceBufferList(SourceBufferList), unSourceBufferList, gTypeSourceBufferList
+  , SourceInfo(SourceInfo), unSourceInfo, gTypeSourceInfo
+  , SpeechSynthesis(SpeechSynthesis), unSpeechSynthesis, gTypeSpeechSynthesis
+  , SpeechSynthesisEvent(SpeechSynthesisEvent), unSpeechSynthesisEvent, gTypeSpeechSynthesisEvent
+  , SpeechSynthesisUtterance(SpeechSynthesisUtterance), unSpeechSynthesisUtterance, gTypeSpeechSynthesisUtterance
+  , SpeechSynthesisVoice(SpeechSynthesisVoice), unSpeechSynthesisVoice, gTypeSpeechSynthesisVoice
+  , Storage(Storage), unStorage, gTypeStorage
+  , StorageEvent(StorageEvent), unStorageEvent, gTypeStorageEvent
+  , StorageInfo(StorageInfo), unStorageInfo, gTypeStorageInfo
+  , StorageQuota(StorageQuota), unStorageQuota, gTypeStorageQuota
+  , StyleMedia(StyleMedia), unStyleMedia, gTypeStyleMedia
+  , StyleSheet(StyleSheet), unStyleSheet, IsStyleSheet, toStyleSheet, gTypeStyleSheet
+  , StyleSheetList(StyleSheetList), unStyleSheetList, gTypeStyleSheetList
+  , SubtleCrypto(SubtleCrypto), unSubtleCrypto, gTypeSubtleCrypto
+  , Text(Text), unText, IsText, toText, gTypeText
+  , TextEvent(TextEvent), unTextEvent, gTypeTextEvent
+  , TextMetrics(TextMetrics), unTextMetrics, gTypeTextMetrics
+  , TextTrack(TextTrack), unTextTrack, gTypeTextTrack
+  , TextTrackCue(TextTrackCue), unTextTrackCue, IsTextTrackCue, toTextTrackCue, gTypeTextTrackCue
+  , TextTrackCueList(TextTrackCueList), unTextTrackCueList, gTypeTextTrackCueList
+  , TextTrackList(TextTrackList), unTextTrackList, gTypeTextTrackList
+  , TimeRanges(TimeRanges), unTimeRanges, gTypeTimeRanges
+  , Touch(Touch), unTouch, gTypeTouch
+  , TouchEvent(TouchEvent), unTouchEvent, gTypeTouchEvent
+  , TouchList(TouchList), unTouchList, gTypeTouchList
+  , TrackEvent(TrackEvent), unTrackEvent, gTypeTrackEvent
+  , TransitionEvent(TransitionEvent), unTransitionEvent, gTypeTransitionEvent
+  , TreeWalker(TreeWalker), unTreeWalker, gTypeTreeWalker
+  , TypeConversions(TypeConversions), unTypeConversions, gTypeTypeConversions
+  , UIEvent(UIEvent), unUIEvent, IsUIEvent, toUIEvent, gTypeUIEvent
+  , UIRequestEvent(UIRequestEvent), unUIRequestEvent, gTypeUIRequestEvent
+  , URL(URL), unURL, gTypeURL
+  , URLUtils(URLUtils), unURLUtils, gTypeURLUtils
+  , UserMessageHandler(UserMessageHandler), unUserMessageHandler, gTypeUserMessageHandler
+  , UserMessageHandlersNamespace(UserMessageHandlersNamespace), unUserMessageHandlersNamespace, gTypeUserMessageHandlersNamespace
+  , VTTCue(VTTCue), unVTTCue, gTypeVTTCue
+  , VTTRegion(VTTRegion), unVTTRegion, gTypeVTTRegion
+  , VTTRegionList(VTTRegionList), unVTTRegionList, gTypeVTTRegionList
+  , ValidityState(ValidityState), unValidityState, gTypeValidityState
+  , VideoPlaybackQuality(VideoPlaybackQuality), unVideoPlaybackQuality, gTypeVideoPlaybackQuality
+  , VideoStreamTrack(VideoStreamTrack), unVideoStreamTrack, gTypeVideoStreamTrack
+  , VideoTrack(VideoTrack), unVideoTrack, gTypeVideoTrack
+  , VideoTrackList(VideoTrackList), unVideoTrackList, gTypeVideoTrackList
+  , WaveShaperNode(WaveShaperNode), unWaveShaperNode, gTypeWaveShaperNode
+  , WebGL2RenderingContext(WebGL2RenderingContext), unWebGL2RenderingContext, gTypeWebGL2RenderingContext
+  , WebGLActiveInfo(WebGLActiveInfo), unWebGLActiveInfo, gTypeWebGLActiveInfo
+  , WebGLBuffer(WebGLBuffer), unWebGLBuffer, gTypeWebGLBuffer
+  , WebGLCompressedTextureATC(WebGLCompressedTextureATC), unWebGLCompressedTextureATC, gTypeWebGLCompressedTextureATC
+  , WebGLCompressedTexturePVRTC(WebGLCompressedTexturePVRTC), unWebGLCompressedTexturePVRTC, gTypeWebGLCompressedTexturePVRTC
+  , WebGLCompressedTextureS3TC(WebGLCompressedTextureS3TC), unWebGLCompressedTextureS3TC, gTypeWebGLCompressedTextureS3TC
+  , WebGLContextAttributes(WebGLContextAttributes), unWebGLContextAttributes, gTypeWebGLContextAttributes
+  , WebGLContextEvent(WebGLContextEvent), unWebGLContextEvent, gTypeWebGLContextEvent
+  , WebGLDebugRendererInfo(WebGLDebugRendererInfo), unWebGLDebugRendererInfo, gTypeWebGLDebugRendererInfo
+  , WebGLDebugShaders(WebGLDebugShaders), unWebGLDebugShaders, gTypeWebGLDebugShaders
+  , WebGLDepthTexture(WebGLDepthTexture), unWebGLDepthTexture, gTypeWebGLDepthTexture
+  , WebGLDrawBuffers(WebGLDrawBuffers), unWebGLDrawBuffers, gTypeWebGLDrawBuffers
+  , WebGLFramebuffer(WebGLFramebuffer), unWebGLFramebuffer, gTypeWebGLFramebuffer
+  , WebGLLoseContext(WebGLLoseContext), unWebGLLoseContext, gTypeWebGLLoseContext
+  , WebGLProgram(WebGLProgram), unWebGLProgram, gTypeWebGLProgram
+  , WebGLQuery(WebGLQuery), unWebGLQuery, gTypeWebGLQuery
+  , WebGLRenderbuffer(WebGLRenderbuffer), unWebGLRenderbuffer, gTypeWebGLRenderbuffer
+  , WebGLRenderingContext(WebGLRenderingContext), unWebGLRenderingContext, gTypeWebGLRenderingContext
+  , WebGLRenderingContextBase(WebGLRenderingContextBase), unWebGLRenderingContextBase, IsWebGLRenderingContextBase, toWebGLRenderingContextBase, gTypeWebGLRenderingContextBase
+  , WebGLSampler(WebGLSampler), unWebGLSampler, gTypeWebGLSampler
+  , WebGLShader(WebGLShader), unWebGLShader, gTypeWebGLShader
+  , WebGLShaderPrecisionFormat(WebGLShaderPrecisionFormat), unWebGLShaderPrecisionFormat, gTypeWebGLShaderPrecisionFormat
+  , WebGLSync(WebGLSync), unWebGLSync, gTypeWebGLSync
+  , WebGLTexture(WebGLTexture), unWebGLTexture, gTypeWebGLTexture
+  , WebGLTransformFeedback(WebGLTransformFeedback), unWebGLTransformFeedback, gTypeWebGLTransformFeedback
+  , WebGLUniformLocation(WebGLUniformLocation), unWebGLUniformLocation, gTypeWebGLUniformLocation
+  , WebGLVertexArrayObject(WebGLVertexArrayObject), unWebGLVertexArrayObject, gTypeWebGLVertexArrayObject
+  , WebGLVertexArrayObjectOES(WebGLVertexArrayObjectOES), unWebGLVertexArrayObjectOES, gTypeWebGLVertexArrayObjectOES
+  , WebKitAnimationEvent(WebKitAnimationEvent), unWebKitAnimationEvent, gTypeWebKitAnimationEvent
+  , WebKitCSSFilterValue(WebKitCSSFilterValue), unWebKitCSSFilterValue, gTypeWebKitCSSFilterValue
+  , WebKitCSSMatrix(WebKitCSSMatrix), unWebKitCSSMatrix, gTypeWebKitCSSMatrix
+  , WebKitCSSRegionRule(WebKitCSSRegionRule), unWebKitCSSRegionRule, gTypeWebKitCSSRegionRule
+  , WebKitCSSTransformValue(WebKitCSSTransformValue), unWebKitCSSTransformValue, gTypeWebKitCSSTransformValue
+  , WebKitCSSViewportRule(WebKitCSSViewportRule), unWebKitCSSViewportRule, gTypeWebKitCSSViewportRule
+  , WebKitNamedFlow(WebKitNamedFlow), unWebKitNamedFlow, gTypeWebKitNamedFlow
+  , WebKitNamespace(WebKitNamespace), unWebKitNamespace, gTypeWebKitNamespace
+  , WebKitPlaybackTargetAvailabilityEvent(WebKitPlaybackTargetAvailabilityEvent), unWebKitPlaybackTargetAvailabilityEvent, gTypeWebKitPlaybackTargetAvailabilityEvent
+  , WebKitPoint(WebKitPoint), unWebKitPoint, gTypeWebKitPoint
+  , WebKitTransitionEvent(WebKitTransitionEvent), unWebKitTransitionEvent, gTypeWebKitTransitionEvent
+  , WebSocket(WebSocket), unWebSocket, gTypeWebSocket
+  , WheelEvent(WheelEvent), unWheelEvent, gTypeWheelEvent
+  , Window(Window), unWindow, gTypeWindow
+  , WindowBase64(WindowBase64), unWindowBase64, gTypeWindowBase64
+  , WindowTimers(WindowTimers), unWindowTimers, gTypeWindowTimers
+  , Worker(Worker), unWorker, gTypeWorker
+  , WorkerGlobalScope(WorkerGlobalScope), unWorkerGlobalScope, IsWorkerGlobalScope, toWorkerGlobalScope, gTypeWorkerGlobalScope
+  , WorkerLocation(WorkerLocation), unWorkerLocation, gTypeWorkerLocation
+  , WorkerNavigator(WorkerNavigator), unWorkerNavigator, gTypeWorkerNavigator
+  , XMLHttpRequest(XMLHttpRequest), unXMLHttpRequest, gTypeXMLHttpRequest
+  , XMLHttpRequestProgressEvent(XMLHttpRequestProgressEvent), unXMLHttpRequestProgressEvent, gTypeXMLHttpRequestProgressEvent
+  , XMLHttpRequestUpload(XMLHttpRequestUpload), unXMLHttpRequestUpload, gTypeXMLHttpRequestUpload
+  , XMLSerializer(XMLSerializer), unXMLSerializer, gTypeXMLSerializer
+  , XPathEvaluator(XPathEvaluator), unXPathEvaluator, gTypeXPathEvaluator
+  , XPathExpression(XPathExpression), unXPathExpression, gTypeXPathExpression
+  , XPathNSResolver(XPathNSResolver), unXPathNSResolver, gTypeXPathNSResolver
+  , XPathResult(XPathResult), unXPathResult, gTypeXPathResult
+  , XSLTProcessor(XSLTProcessor), unXSLTProcessor, gTypeXSLTProcessor
+-- AUTO GENERATION ENDS HERE
+  ) where
+
+import Control.Applicative ((<$>))
+import qualified Data.Text as T (unpack, Text)
+import qualified Data.Text.Lazy as LT (Text)
+import Data.JSString (pack, unpack)
+import Data.JSString.Text (textToJSString, textFromJSString, lazyTextToJSString, lazyTextFromJSString)
+import GHCJS.Types (JSVal(..), nullRef, isNull, isUndefined, JSString(..))
+import GHCJS.Marshal (ToJSVal(..), FromJSVal(..))
+import GHCJS.Marshal.Pure (PToJSVal(..), PFromJSVal(..))
+import GHCJS.Nullable (Nullable(..), nullableToMaybe, maybeToNullable)
+import GHCJS.Foreign.Callback.Internal (Callback(..))
+import Control.Monad.IO.Class (MonadIO(..))
+import Data.Int (Int8, Int16, Int32, Int64)
+import Data.Word (Word8, Word16, Word32, Word64)
+import Data.Coerce (coerce, Coercible)
+import Data.Monoid ((<>))
+#if MIN_VERSION_base(4,9,0)
+import GHC.Stack (HasCallStack)
+#elif MIN_VERSION_base(4,8,0)
+import GHC.Stack (CallStack)
+import GHC.Exts (Constraint)
+type HasCallStack = ((?callStack :: CallStack) :: Constraint)
+#else
+import GHC.Exts (Constraint)
+type HasCallStack = (() :: Constraint)
+#endif
+
+-- | Identifies a JavaScript execution context.
+--   When using GHCJS this is just '()' since their is only one context.
+--   When using GHC it includes the functions JSaddle needs to communicate
+--   with the JavaScript context.
+type JSContextRef = ()
+
+-- | This is the same as 'JSContextRef' except when using ghcjs-dom-webkit with GHC (instead of ghcjs-dom-jsaddle)
+type DOMContext = ()
+
+-- | The 'JSM' monad keeps track of the JavaScript execution context.
+--
+--   When using GHCJS it is `IO`.
+--
+--   Given a 'JSM' function and a 'JSContextRef' you can run the
+--   function like this...
+--
+-- > runJSM jsmFunction javaScriptContext
+type JSM = IO
+
+-- | This is the same as 'JSM' except when using ghcjs-dom-webkit with GHC (instead of ghcjs-dom-jsaddle)
+type DOM = IO
+
+-- | The 'MonadJSM' is to 'JSM' what 'MonadIO' is to 'IO'.
+--   When using GHCJS it is 'MonadIO'.
+type MonadJSM = MonadIO
+
+-- | This is the same as 'MonadJSM' except when using ghcjs-dom-webkit with GHC (instead of ghcjs-dom-jsaddle)
+type MonadDOM = MonadIO
+
+-- | The 'liftJSM' is to 'JSM' what 'liftIO' is to 'IO'.
+--   When using GHCJS it is 'liftIO'.
+liftJSM :: MonadJSM m => JSM a -> m a
+liftJSM = liftIO
+
+-- | This is the same as 'liftJSM' except when using ghcjs-dom-webkit with GHC (instead of ghcjs-dom-jsaddle)
+liftDOM :: MonadDOM m => DOM a -> m a
+liftDOM = liftIO
+
+-- | Gets the JavaScript context from the monad
+askJSM :: MonadJSM m => m JSContextRef
+askJSM = return ()
+
+-- | This is the same as 'askJSM' except when using ghcjs-dom-webkit with GHC (instead of ghcjs-dom-jsaddle)
+askDOM :: MonadDOM m => m DOMContext
+askDOM = return ()
+
+-- | Runs a 'JSM' JavaScript function in a given JavaScript context.
+runJSM :: MonadIO m => JSM a -> JSContextRef -> m a
+runJSM f = liftIO . const f
+
+-- | This is the same as 'runJSM' except when using ghcjs-dom-webkit with GHC (instead of ghcjs-dom-jsaddle)
+runDOM :: MonadIO m => DOM a -> DOMContext -> m a
+runDOM f = liftIO . const f
+
+maybeJSNullOrUndefined :: JSVal -> Maybe JSVal
+maybeJSNullOrUndefined r | isNull r || isUndefined r = Nothing
+maybeJSNullOrUndefined r = Just r
+
+propagateGError = id
+
+newtype GType = GType JSVal
+
+foreign import javascript unsafe "$r = $1.name;" gTypeToString :: GType -> JSString
+
+foreign import javascript unsafe
+  "$1===$2" js_eq :: JSVal -> JSVal -> Bool
+
+strictEqual :: (ToJSVal a, ToJSVal b) => a -> b -> JSM Bool
+strictEqual a b = do
+    aval <- toJSVal a
+    bval <- toJSVal b
+    return $ js_eq aval bval
+
+foreign import javascript unsafe "h$isInstanceOf $1 $2"
+    typeInstanceIsA' :: JSVal -> JSVal -> Bool
+
+typeInstanceIsA o (GType t) = typeInstanceIsA' o t
+
+-- | Safe but slow way to cast
+--
+-- > castTo Element x >>= \case
+-- >     Nothing      -> error "Was not an element"
+-- >     Just element -> ...
+castTo :: forall obj obj' m. (IsGObject obj, IsGObject obj', MonadJSM m) => (JSVal -> obj') -> obj -> m (Maybe obj')
+castTo constructor obj = liftJSM $ do
+  let gtype = typeGType (undefined :: obj')
+      jsval = coerce obj
+  if typeInstanceIsA jsval gtype
+    then return . Just $ constructor jsval
+    else return Nothing
+
+-- | Unsafe way to cast.  Slow but if it fails an error message will
+--   result and the message should be clear (uses HasCallStack).
+--
+-- > element <- unsafeCastTo Element x
+unsafeCastTo :: forall obj obj' m. (HasCallStack, IsGObject obj, IsGObject obj', MonadJSM m) => (JSVal -> obj') -> obj -> m obj'
+unsafeCastTo constructor obj = liftJSM $ do
+  let gtype = typeGType (undefined :: obj')
+      jsval = coerce obj
+  if typeInstanceIsA jsval gtype
+    then return $ constructor jsval
+    else do
+      let srcType  = textFromJSString . gTypeToString $ typeGType obj
+          destType = textFromJSString . gTypeToString $ typeGType (undefined :: obj')
+      error $ "unsafeCastTo :: invalid conversion from " <> T.unpack srcType <> " to "
+        <> T.unpack destType <> " requested."
+
+-- | Unsafe way to cast, super fast but if it fails you program
+--   will probably crash later on in some unpredictable way.
+--
+-- > element <- uncheckedCastTo Element x
+uncheckedCastTo :: (IsGObject obj, IsGObject obj') => (JSVal -> obj') -> obj -> obj'
+uncheckedCastTo constructor = constructor . coerce
+
+-- | Determine if this is an instance of a particular type
+--
+isA :: IsGObject o => o -> GType -> Bool
+isA obj = typeInstanceIsA (unGObject $ toGObject obj)
+
+newtype GObject = GObject { unGObject :: JSVal }
+
+class (ToJSVal o, FromJSVal o, Coercible o JSVal) => IsGObject o where
+  -- | Given object get the GType of the type.  The actual argument
+  --   passed in is ignored.
+  typeGType :: o -> GType
+
+-- | Safe upcast.
+toGObject :: IsGObject o => o -> GObject
+toGObject = GObject . coerce
+
+instance PToJSVal GObject where
+  pToJSVal = unGObject
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal GObject where
+  pFromJSVal = GObject
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal GObject where
+  toJSVal = return . unGObject
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal GObject where
+  fromJSVal = return . fmap GObject . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+--instance IsGObject o => PToJSVal o where
+--  pToJSVal = unGObject . toGObject
+--  {-# INLINE pToJSVal #-}
+--
+--instance IsGObject o => PFromJSVal o where
+--  pFromJSVal = unsafeCastGObject . GObject . castRef
+--  {-# INLINE pFromJSVal #-}
+--
+--instance IsGObject o => ToJSVal o where
+--  toJSVal = return . unGObject . toGObject
+--  {-# INLINE toJSVal #-}
+--
+--instance IsGObject o => FromJSVal o where
+--  fromJSVal = return . fmap (unsafeCastGObject . GObject . castRef) . maybeJSNullOrUndefined
+--  {-# INLINE fromJSVal #-}
+
+instance IsGObject GObject where
+  typeGType _ = gTypeGObject
+  {-# INLINE typeGType #-}
+
+castToGObject :: IsGObject obj => obj -> IO obj
+castToGObject = return
+
+foreign import javascript unsafe "Object" gTypeGObject :: GType
+
+foreign import javascript unsafe "$1[\"toString\"]()" js_objectToString :: GObject -> IO JSString
+
+objectToString :: (MonadIO m, IsGObject self, FromJSString result) => self -> m result
+objectToString self = liftIO (fromJSString <$> js_objectToString (toGObject self))
+
+-- | Fastest string type to use when you just
+--   want to take a string from the DOM then
+--   give it back as is.
+type DOMString = JSString
+
+class (PToJSVal a, ToJSVal a) => ToJSString a
+class (PFromJSVal a, FromJSVal a) => FromJSString a
+
+toJSString :: ToJSString a => a -> JSString
+toJSString = pFromJSVal . pToJSVal
+{-# INLINE toJSString #-}
+
+fromJSString :: FromJSString a => JSString -> a
+fromJSString = pFromJSVal . pToJSVal
+{-# INLINE fromJSString #-}
+
+toMaybeJSString :: ToJSString a => Maybe a -> Nullable JSString
+toMaybeJSString = Nullable . pToJSVal
+{-# INLINE toMaybeJSString #-}
+
+fromMaybeJSString :: FromJSString a => Nullable JSString -> Maybe a
+fromMaybeJSString (Nullable r) = pFromJSVal r
+{-# INLINE fromMaybeJSString #-}
+
+instance ToJSString   [Char]
+instance FromJSString [Char]
+instance ToJSString   T.Text
+instance FromJSString T.Text
+instance ToJSString   JSString
+instance FromJSString JSString
+
+type ToDOMString s = ToJSString s
+type FromDOMString s = FromJSString s
+type IsDOMString s = (ToDOMString s, FromDOMString s)
+
+-- Callbacks
+newtype AudioBufferCallback = AudioBufferCallback (Callback (JSVal -> IO ()))
+instance PToJSVal AudioBufferCallback where pToJSVal (AudioBufferCallback (Callback r)) = r
+newtype DatabaseCallback = DatabaseCallback (Callback (JSVal -> IO ()))
+instance PToJSVal DatabaseCallback where pToJSVal (DatabaseCallback (Callback r)) = r
+newtype MediaQueryListListener = MediaQueryListListener (Callback (JSVal -> IO ()))
+instance PToJSVal MediaQueryListListener where pToJSVal (MediaQueryListListener (Callback r)) = r
+newtype MediaStreamTrackSourcesCallback = MediaStreamTrackSourcesCallback (Callback (JSVal -> IO ()))
+instance PToJSVal MediaStreamTrackSourcesCallback where pToJSVal (MediaStreamTrackSourcesCallback (Callback r)) = r
+newtype NavigatorUserMediaErrorCallback = NavigatorUserMediaErrorCallback (Callback (JSVal -> IO ()))
+instance PToJSVal NavigatorUserMediaErrorCallback where pToJSVal (NavigatorUserMediaErrorCallback (Callback r)) = r
+newtype NavigatorUserMediaSuccessCallback = NavigatorUserMediaSuccessCallback (Callback (JSVal -> IO ()))
+instance PToJSVal NavigatorUserMediaSuccessCallback where pToJSVal (NavigatorUserMediaSuccessCallback (Callback r)) = r
+newtype NotificationPermissionCallback permissions = NotificationPermissionCallback (Callback (JSVal -> IO ()))
+instance PToJSVal (NotificationPermissionCallback permissions) where pToJSVal (NotificationPermissionCallback (Callback r)) = r
+newtype PositionCallback = PositionCallback (Callback (JSVal -> IO ()))
+instance PToJSVal PositionCallback where pToJSVal (PositionCallback (Callback r)) = r
+newtype PositionErrorCallback = PositionErrorCallback (Callback (JSVal -> IO ()))
+instance PToJSVal PositionErrorCallback where pToJSVal (PositionErrorCallback (Callback r)) = r
+newtype RequestAnimationFrameCallback = RequestAnimationFrameCallback (Callback (JSVal -> IO ()))
+instance PToJSVal RequestAnimationFrameCallback where pToJSVal (RequestAnimationFrameCallback (Callback r)) = r
+newtype RTCPeerConnectionErrorCallback = RTCPeerConnectionErrorCallback (Callback (JSVal -> IO ()))
+instance PToJSVal RTCPeerConnectionErrorCallback where pToJSVal (RTCPeerConnectionErrorCallback (Callback r)) = r
+newtype RTCSessionDescriptionCallback = RTCSessionDescriptionCallback (Callback (JSVal -> IO ()))
+instance PToJSVal RTCSessionDescriptionCallback where pToJSVal (RTCSessionDescriptionCallback (Callback r)) = r
+newtype RTCStatsCallback = RTCStatsCallback (Callback (JSVal -> IO ()))
+instance PToJSVal RTCStatsCallback where pToJSVal (RTCStatsCallback (Callback r)) = r
+newtype SQLStatementCallback = SQLStatementCallback (Callback (JSVal -> JSVal -> IO ()))
+instance PToJSVal SQLStatementCallback where pToJSVal (SQLStatementCallback (Callback r)) = r
+newtype SQLStatementErrorCallback = SQLStatementErrorCallback (Callback (JSVal -> JSVal -> IO ()))
+instance PToJSVal SQLStatementErrorCallback where pToJSVal (SQLStatementErrorCallback (Callback r)) = r
+newtype SQLTransactionCallback = SQLTransactionCallback (Callback (JSVal -> IO ()))
+instance PToJSVal SQLTransactionCallback where pToJSVal (SQLTransactionCallback (Callback r)) = r
+newtype SQLTransactionErrorCallback = SQLTransactionErrorCallback (Callback (JSVal -> IO ()))
+instance PToJSVal SQLTransactionErrorCallback where pToJSVal (SQLTransactionErrorCallback (Callback r)) = r
+newtype StorageErrorCallback = StorageErrorCallback (Callback (JSVal -> IO ()))
+instance PToJSVal StorageErrorCallback where pToJSVal (StorageErrorCallback (Callback r)) = r
+newtype StorageQuotaCallback = StorageQuotaCallback (Callback (JSVal -> IO ()))
+instance PToJSVal StorageQuotaCallback where pToJSVal (StorageQuotaCallback (Callback r)) = r
+newtype StorageUsageCallback = StorageUsageCallback (Callback (JSVal -> JSVal -> IO ()))
+instance PToJSVal StorageUsageCallback where pToJSVal (StorageUsageCallback (Callback r)) = r
+newtype StringCallback s = StringCallback (Callback (JSVal -> IO ()))
+instance PToJSVal (StringCallback s) where pToJSVal (StringCallback (Callback r)) = r
+newtype VoidCallback = VoidCallback (Callback (IO ()))
+instance PToJSVal VoidCallback where pToJSVal (VoidCallback (Callback r)) = r
+
+-- Custom types
+newtype SerializedScriptValue = SerializedScriptValue { unSerializedScriptValue :: JSVal }
+
+instance Eq SerializedScriptValue where
+  (SerializedScriptValue a) == (SerializedScriptValue b) = js_eq a b
+
+instance PToJSVal SerializedScriptValue where
+  pToJSVal = unSerializedScriptValue
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SerializedScriptValue where
+  pFromJSVal = SerializedScriptValue
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SerializedScriptValue where
+  toJSVal = return . unSerializedScriptValue
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SerializedScriptValue where
+  fromJSVal = return . fmap SerializedScriptValue . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+class IsGObject o => IsSerializedScriptValue o
+toSerializedScriptValue :: IsSerializedScriptValue o => o -> SerializedScriptValue
+toSerializedScriptValue = SerializedScriptValue . coerce
+
+instance IsSerializedScriptValue SerializedScriptValue
+instance IsGObject SerializedScriptValue where
+  typeGType _ = error "Unable to get the JavaScript type of SerializedScriptValue"
+
+newtype PositionOptions = PositionOptions { unPositionOptions :: JSVal }
+
+instance Eq PositionOptions where
+  (PositionOptions a) == (PositionOptions b) = js_eq a b
+
+instance PToJSVal PositionOptions where
+  pToJSVal = unPositionOptions
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal PositionOptions where
+  pFromJSVal = PositionOptions
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal PositionOptions where
+  toJSVal = return . unPositionOptions
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal PositionOptions where
+  fromJSVal = return . fmap PositionOptions . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+class IsGObject o => IsPositionOptions o
+toPositionOptions :: IsPositionOptions o => o -> PositionOptions
+toPositionOptions = PositionOptions . coerce
+
+instance IsPositionOptions PositionOptions
+instance IsGObject PositionOptions where
+  typeGType _ = error "Unable to get the JavaScript type of PositionOptions"
+
+newtype Dictionary = Dictionary { unDictionary :: JSVal }
+
+instance Eq Dictionary where
+  (Dictionary a) == (Dictionary b) = js_eq a b
+
+instance PToJSVal Dictionary where
+  pToJSVal = unDictionary
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal Dictionary where
+  pFromJSVal = Dictionary
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal Dictionary where
+  toJSVal = return . unDictionary
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal Dictionary where
+  fromJSVal = return . fmap Dictionary . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+class IsGObject o => IsDictionary o
+toDictionary :: IsDictionary o => o -> Dictionary
+toDictionary = Dictionary . coerce
+
+instance IsDictionary Dictionary
+instance IsGObject Dictionary where
+  typeGType _ = error "Unable to get the JavaScript type of Dictionary"
+
+newtype BlobPropertyBag = BlobPropertyBag { unBlobPropertyBag :: JSVal }
+
+instance Eq BlobPropertyBag where
+  (BlobPropertyBag a) == (BlobPropertyBag b) = js_eq a b
+
+instance PToJSVal BlobPropertyBag where
+  pToJSVal = unBlobPropertyBag
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal BlobPropertyBag where
+  pFromJSVal = BlobPropertyBag
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal BlobPropertyBag where
+  toJSVal = return . unBlobPropertyBag
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal BlobPropertyBag where
+  fromJSVal = return . fmap BlobPropertyBag . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+class IsGObject o => IsBlobPropertyBag o
+toBlobPropertyBag :: IsBlobPropertyBag o => o -> BlobPropertyBag
+toBlobPropertyBag = BlobPropertyBag . coerce
+
+instance IsBlobPropertyBag BlobPropertyBag
+instance IsGObject BlobPropertyBag where
+  typeGType _ = error "Unable to get the JavaScript type of BlobPropertyBag"
+
+newtype MutationCallback = MutationCallback { unMutationCallback :: JSVal }
+
+instance Eq MutationCallback where
+  (MutationCallback a) == (MutationCallback b) = js_eq a b
+
+instance PToJSVal MutationCallback where
+  pToJSVal = unMutationCallback
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal MutationCallback where
+  pFromJSVal = MutationCallback
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal MutationCallback where
+  toJSVal = return . unMutationCallback
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal MutationCallback where
+  fromJSVal = return . fmap MutationCallback . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+class IsGObject o => IsMutationCallback o
+toMutationCallback :: IsMutationCallback o => o -> MutationCallback
+toMutationCallback = MutationCallback . coerce
+
+instance IsMutationCallback MutationCallback
+instance IsGObject MutationCallback where
+  typeGType _ = error "Unable to get the JavaScript type of MutationCallback"
+
+newtype Promise = Promise { unPromise :: JSVal }
+
+instance Eq Promise where
+  (Promise a) == (Promise b) = js_eq a b
+
+instance PToJSVal Promise where
+  pToJSVal = unPromise
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal Promise where
+  pFromJSVal = Promise
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal Promise where
+  toJSVal = return . unPromise
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal Promise where
+  fromJSVal = return . fmap Promise . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+class IsGObject o => IsPromise o
+toPromise :: IsPromise o => o -> Promise
+toPromise = Promise . coerce
+
+instance IsPromise Promise
+instance IsGObject Promise where
+  typeGType _ = gTypePromise
+
+foreign import javascript unsafe "window[\"Promise\"]" gTypePromise :: GType
+
+newtype ArrayBuffer = ArrayBuffer { unArrayBuffer :: JSVal }
+
+instance Eq ArrayBuffer where
+  (ArrayBuffer a) == (ArrayBuffer b) = js_eq a b
+
+instance PToJSVal ArrayBuffer where
+  pToJSVal = unArrayBuffer
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal ArrayBuffer where
+  pFromJSVal = ArrayBuffer
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal ArrayBuffer where
+  toJSVal = return . unArrayBuffer
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal ArrayBuffer where
+  fromJSVal = return . fmap ArrayBuffer . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+class IsGObject o => IsArrayBuffer o
+toArrayBuffer :: IsArrayBuffer o => o -> ArrayBuffer
+toArrayBuffer = ArrayBuffer . coerce
+
+instance IsArrayBuffer ArrayBuffer
+instance IsGObject ArrayBuffer where
+  typeGType _ = gTypeArrayBuffer
+
+foreign import javascript unsafe "window[\"ArrayBuffer\"]" gTypeArrayBuffer :: GType
+
+newtype Float32Array = Float32Array { unFloat32Array :: JSVal }
+
+instance Eq Float32Array where
+  (Float32Array a) == (Float32Array b) = js_eq a b
+
+instance PToJSVal Float32Array where
+  pToJSVal = unFloat32Array
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal Float32Array where
+  pFromJSVal = Float32Array
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal Float32Array where
+  toJSVal = return . unFloat32Array
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal Float32Array where
+  fromJSVal = return . fmap Float32Array . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+class IsGObject o => IsFloat32Array o
+toFloat32Array :: IsFloat32Array o => o -> Float32Array
+toFloat32Array = Float32Array . coerce
+
+instance IsFloat32Array Float32Array
+instance IsGObject Float32Array where
+  typeGType _ = gTypeFloat32Array
+
+foreign import javascript unsafe "window[\"Float32Array\"]" gTypeFloat32Array :: GType
+
+newtype Float64Array = Float64Array { unFloat64Array :: JSVal }
+
+instance Eq Float64Array where
+  (Float64Array a) == (Float64Array b) = js_eq a b
+
+instance PToJSVal Float64Array where
+  pToJSVal = unFloat64Array
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal Float64Array where
+  pFromJSVal = Float64Array
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal Float64Array where
+  toJSVal = return . unFloat64Array
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal Float64Array where
+  fromJSVal = return . fmap Float64Array . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+class IsGObject o => IsFloat64Array o
+toFloat64Array :: IsFloat64Array o => o -> Float64Array
+toFloat64Array = Float64Array . coerce
+
+instance IsFloat64Array Float64Array
+instance IsGObject Float64Array where
+  typeGType _ = gTypeFloat64Array
+
+foreign import javascript unsafe "window[\"Float64Array\"]" gTypeFloat64Array :: GType
+
+newtype Uint8Array = Uint8Array { unUint8Array :: JSVal }
+
+instance Eq Uint8Array where
+  (Uint8Array a) == (Uint8Array b) = js_eq a b
+
+instance PToJSVal Uint8Array where
+  pToJSVal = unUint8Array
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal Uint8Array where
+  pFromJSVal = Uint8Array
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal Uint8Array where
+  toJSVal = return . unUint8Array
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal Uint8Array where
+  fromJSVal = return . fmap Uint8Array . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+class IsGObject o => IsUint8Array o
+toUint8Array :: IsUint8Array o => o -> Uint8Array
+toUint8Array = Uint8Array . coerce
+
+instance IsUint8Array Uint8Array
+instance IsGObject Uint8Array where
+  typeGType _ = gTypeUint8Array
+
+foreign import javascript unsafe "window[\"Uint8Array\"]" gTypeUint8Array :: GType
+
+newtype Uint8ClampedArray = Uint8ClampedArray { unUint8ClampedArray :: JSVal }
+
+instance Eq Uint8ClampedArray where
+  (Uint8ClampedArray a) == (Uint8ClampedArray b) = js_eq a b
+
+instance PToJSVal Uint8ClampedArray where
+  pToJSVal = unUint8ClampedArray
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal Uint8ClampedArray where
+  pFromJSVal = Uint8ClampedArray
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal Uint8ClampedArray where
+  toJSVal = return . unUint8ClampedArray
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal Uint8ClampedArray where
+  fromJSVal = return . fmap Uint8ClampedArray . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+class IsGObject o => IsUint8ClampedArray o
+toUint8ClampedArray :: IsUint8ClampedArray o => o -> Uint8ClampedArray
+toUint8ClampedArray = Uint8ClampedArray . coerce
+
+instance IsUint8ClampedArray Uint8ClampedArray
+instance IsGObject Uint8ClampedArray where
+  typeGType _ = gTypeUint8ClampedArray
+
+foreign import javascript unsafe "window[\"Uint8ClampedArray\"]" gTypeUint8ClampedArray :: GType
+
+newtype Uint16Array = Uint16Array { unUint16Array :: JSVal }
+
+instance Eq Uint16Array where
+  (Uint16Array a) == (Uint16Array b) = js_eq a b
+
+instance PToJSVal Uint16Array where
+  pToJSVal = unUint16Array
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal Uint16Array where
+  pFromJSVal = Uint16Array
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal Uint16Array where
+  toJSVal = return . unUint16Array
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal Uint16Array where
+  fromJSVal = return . fmap Uint16Array . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+class IsGObject o => IsUint16Array o
+toUint16Array :: IsUint16Array o => o -> Uint16Array
+toUint16Array = Uint16Array . coerce
+
+instance IsUint16Array Uint16Array
+instance IsGObject Uint16Array where
+  typeGType _ = gTypeUint16Array
+
+foreign import javascript unsafe "window[\"Uint16Array\"]" gTypeUint16Array :: GType
+
+newtype Uint32Array = Uint32Array { unUint32Array :: JSVal }
+
+instance Eq Uint32Array where
+  (Uint32Array a) == (Uint32Array b) = js_eq a b
+
+instance PToJSVal Uint32Array where
+  pToJSVal = unUint32Array
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal Uint32Array where
+  pFromJSVal = Uint32Array
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal Uint32Array where
+  toJSVal = return . unUint32Array
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal Uint32Array where
+  fromJSVal = return . fmap Uint32Array . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+class IsGObject o => IsUint32Array o
+toUint32Array :: IsUint32Array o => o -> Uint32Array
+toUint32Array = Uint32Array . coerce
+
+instance IsUint32Array Uint32Array
+instance IsGObject Uint32Array where
+  typeGType _ = gTypeUint32Array
+
+foreign import javascript unsafe "window[\"Uint32Array\"]" gTypeUint32Array :: GType
+
+newtype Int8Array = Int8Array { unInt8Array :: JSVal }
+
+instance Eq Int8Array where
+  (Int8Array a) == (Int8Array b) = js_eq a b
+
+instance PToJSVal Int8Array where
+  pToJSVal = unInt8Array
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal Int8Array where
+  pFromJSVal = Int8Array
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal Int8Array where
+  toJSVal = return . unInt8Array
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal Int8Array where
+  fromJSVal = return . fmap Int8Array . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+class IsGObject o => IsInt8Array o
+toInt8Array :: IsInt8Array o => o -> Int8Array
+toInt8Array = Int8Array . coerce
+
+instance IsInt8Array Int8Array
+instance IsGObject Int8Array where
+  typeGType _ = gTypeInt8Array
+
+foreign import javascript unsafe "window[\"Int8Array\"]" gTypeInt8Array :: GType
+
+newtype Int16Array = Int16Array { unInt16Array :: JSVal }
+
+instance Eq Int16Array where
+  (Int16Array a) == (Int16Array b) = js_eq a b
+
+instance PToJSVal Int16Array where
+  pToJSVal = unInt16Array
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal Int16Array where
+  pFromJSVal = Int16Array
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal Int16Array where
+  toJSVal = return . unInt16Array
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal Int16Array where
+  fromJSVal = return . fmap Int16Array . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+class IsGObject o => IsInt16Array o
+toInt16Array :: IsInt16Array o => o -> Int16Array
+toInt16Array = Int16Array . coerce
+
+instance IsInt16Array Int16Array
+instance IsGObject Int16Array where
+  typeGType _ = gTypeInt16Array
+
+foreign import javascript unsafe "window[\"Int16Array\"]" gTypeInt16Array :: GType
+
+newtype Int32Array = Int32Array { unInt32Array :: JSVal }
+
+instance Eq Int32Array where
+  (Int32Array a) == (Int32Array b) = js_eq a b
+
+instance PToJSVal Int32Array where
+  pToJSVal = unInt32Array
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal Int32Array where
+  pFromJSVal = Int32Array
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal Int32Array where
+  toJSVal = return . unInt32Array
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal Int32Array where
+  fromJSVal = return . fmap Int32Array . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+class IsGObject o => IsInt32Array o
+toInt32Array :: IsInt32Array o => o -> Int32Array
+toInt32Array = Int32Array . coerce
+
+instance IsInt32Array Int32Array
+instance IsGObject Int32Array where
+  typeGType _ = gTypeInt32Array
+
+foreign import javascript unsafe "window[\"Int32Array\"]" gTypeInt32Array :: GType
+
+newtype ObjectArray = ObjectArray { unObjectArray :: JSVal }
+
+instance Eq ObjectArray where
+  (ObjectArray a) == (ObjectArray b) = js_eq a b
+
+instance PToJSVal ObjectArray where
+  pToJSVal = unObjectArray
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal ObjectArray where
+  pFromJSVal = ObjectArray
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal ObjectArray where
+  toJSVal = return . unObjectArray
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal ObjectArray where
+  fromJSVal = return . fmap ObjectArray . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+class IsGObject o => IsObjectArray o
+toObjectArray :: IsObjectArray o => o -> ObjectArray
+toObjectArray = ObjectArray . coerce
+
+instance IsObjectArray ObjectArray
+instance IsGObject ObjectArray where
+  typeGType _ = error "Unable to get the JavaScript type of ObjectArray"
+
+newtype ArrayBufferView = ArrayBufferView { unArrayBufferView :: JSVal }
+
+instance Eq ArrayBufferView where
+  (ArrayBufferView a) == (ArrayBufferView b) = js_eq a b
+
+instance PToJSVal ArrayBufferView where
+  pToJSVal = unArrayBufferView
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal ArrayBufferView where
+  pFromJSVal = ArrayBufferView
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal ArrayBufferView where
+  toJSVal = return . unArrayBufferView
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal ArrayBufferView where
+  fromJSVal = return . fmap ArrayBufferView . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+class IsGObject o => IsArrayBufferView o
+toArrayBufferView :: IsArrayBufferView o => o -> ArrayBufferView
+toArrayBufferView = ArrayBufferView . coerce
+
+instance IsArrayBufferView ArrayBufferView
+instance IsGObject ArrayBufferView where
+  typeGType _ = error "Unable to get the JavaScript type of ArrayBufferView"
+
+newtype Array = Array { unArray :: JSVal }
+
+instance Eq Array where
+  (Array a) == (Array b) = js_eq a b
+
+instance PToJSVal Array where
+  pToJSVal = unArray
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal Array where
+  pFromJSVal = Array
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal Array where
+  toJSVal = return . unArray
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal Array where
+  fromJSVal = return . fmap Array . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+class IsGObject o => IsArray o
+toArray :: IsArray o => o -> Array
+toArray = Array . coerce
+
+instance IsArray Array
+instance IsGObject Array where
+  typeGType _ = gTypeArray
+
+foreign import javascript unsafe "window[\"Array\"]" gTypeArray :: GType
+
+newtype Date = Date { unDate :: JSVal }
+
+instance Eq Date where
+  (Date a) == (Date b) = js_eq a b
+
+instance PToJSVal Date where
+  pToJSVal = unDate
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal Date where
+  pFromJSVal = Date
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal Date where
+  toJSVal = return . unDate
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal Date where
+  fromJSVal = return . fmap Date . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+class IsGObject o => IsDate o
+toDate :: IsDate o => o -> Date
+toDate = Date . coerce
+
+instance IsDate Date
+instance IsGObject Date where
+  typeGType _ = gTypeDate
+
+foreign import javascript unsafe "window[\"Date\"]" gTypeDate :: GType
+
+newtype Acceleration = Acceleration { unAcceleration :: JSVal }
+
+instance Eq Acceleration where
+  (Acceleration a) == (Acceleration b) = js_eq a b
+
+instance PToJSVal Acceleration where
+  pToJSVal = unAcceleration
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal Acceleration where
+  pFromJSVal = Acceleration
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal Acceleration where
+  toJSVal = return . unAcceleration
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal Acceleration where
+  fromJSVal = return . fmap Acceleration . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+class IsGObject o => IsAcceleration o
+toAcceleration :: IsAcceleration o => o -> Acceleration
+toAcceleration = Acceleration . coerce
+
+instance IsAcceleration Acceleration
+instance IsGObject Acceleration where
+  typeGType _ = error "Unable to get the JavaScript type of Acceleration"
+
+newtype RotationRate = RotationRate { unRotationRate :: JSVal }
+
+instance Eq RotationRate where
+  (RotationRate a) == (RotationRate b) = js_eq a b
+
+instance PToJSVal RotationRate where
+  pToJSVal = unRotationRate
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal RotationRate where
+  pFromJSVal = RotationRate
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal RotationRate where
+  toJSVal = return . unRotationRate
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal RotationRate where
+  fromJSVal = return . fmap RotationRate . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+class IsGObject o => IsRotationRate o
+toRotationRate :: IsRotationRate o => o -> RotationRate
+toRotationRate = RotationRate . coerce
+
+instance IsRotationRate RotationRate
+instance IsGObject RotationRate where
+  typeGType _ = error "Unable to get the JavaScript type of RotationRate"
+
+newtype Algorithm = Algorithm { unAlgorithm :: JSVal }
+
+instance Eq Algorithm where
+  (Algorithm a) == (Algorithm b) = js_eq a b
+
+instance PToJSVal Algorithm where
+  pToJSVal = unAlgorithm
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal Algorithm where
+  pFromJSVal = Algorithm
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal Algorithm where
+  toJSVal = return . unAlgorithm
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal Algorithm where
+  fromJSVal = return . fmap Algorithm . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+class IsGObject o => IsAlgorithm o
+toAlgorithm :: IsAlgorithm o => o -> Algorithm
+toAlgorithm = Algorithm . coerce
+
+instance IsAlgorithm Algorithm
+instance IsGObject Algorithm where
+  typeGType _ = error "Unable to get the JavaScript type of Algorithm"
+
+newtype CryptoOperationData = CryptoOperationData { unCryptoOperationData :: JSVal }
+
+instance Eq CryptoOperationData where
+  (CryptoOperationData a) == (CryptoOperationData b) = js_eq a b
+
+instance PToJSVal CryptoOperationData where
+  pToJSVal = unCryptoOperationData
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal CryptoOperationData where
+  pFromJSVal = CryptoOperationData
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal CryptoOperationData where
+  toJSVal = return . unCryptoOperationData
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal CryptoOperationData where
+  fromJSVal = return . fmap CryptoOperationData . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+class IsGObject o => IsCryptoOperationData o
+toCryptoOperationData :: IsCryptoOperationData o => o -> CryptoOperationData
+toCryptoOperationData = CryptoOperationData . coerce
+
+instance IsCryptoOperationData CryptoOperationData
+instance IsGObject CryptoOperationData where
+  typeGType _ = error "Unable to get the JavaScript type of CryptoOperationData"
+instance IsCryptoOperationData ArrayBuffer
+instance IsCryptoOperationData ArrayBufferView
+
+newtype CanvasStyle = CanvasStyle { unCanvasStyle :: JSVal }
+
+instance Eq CanvasStyle where
+  (CanvasStyle a) == (CanvasStyle b) = js_eq a b
+
+instance PToJSVal CanvasStyle where
+  pToJSVal = unCanvasStyle
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal CanvasStyle where
+  pFromJSVal = CanvasStyle
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal CanvasStyle where
+  toJSVal = return . unCanvasStyle
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal CanvasStyle where
+  fromJSVal = return . fmap CanvasStyle . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+class IsGObject o => IsCanvasStyle o
+toCanvasStyle :: IsCanvasStyle o => o -> CanvasStyle
+toCanvasStyle = CanvasStyle . coerce
+
+instance IsCanvasStyle CanvasStyle
+instance IsGObject CanvasStyle where
+  typeGType _ = error "Unable to get the JavaScript type of CanvasStyle"
+instance IsCanvasStyle CanvasGradient
+instance IsCanvasStyle CanvasPattern
+
+newtype DOMException = DOMException { unDOMException :: JSVal }
+
+instance Eq DOMException where
+  (DOMException a) == (DOMException b) = js_eq a b
+
+instance PToJSVal DOMException where
+  pToJSVal = unDOMException
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal DOMException where
+  pFromJSVal = DOMException
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal DOMException where
+  toJSVal = return . unDOMException
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal DOMException where
+  fromJSVal = return . fmap DOMException . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+class IsGObject o => IsDOMException o
+toDOMException :: IsDOMException o => o -> DOMException
+toDOMException = DOMException . coerce
+
+instance IsDOMException DOMException
+instance IsGObject DOMException where
+  typeGType _ = error "Unable to get the JavaScript type of DOMException"
+
+type GLenum = Word32
+type GLboolean = Bool
+type GLbitfield = Word32
+type GLbyte = Int8
+type GLshort = Int16
+type GLint = Int32
+type GLint64 = Int64
+type GLsizei = Int32
+type GLintptr = Int64
+type GLsizeiptr = Int64
+type GLubyte = Word8
+type GLushort = Word16
+type GLuint = Word32
+type GLuint64 = Word64
+type GLfloat = Double
+type GLclampf = Double
+
+-- AUTO GENERATION STARTS HERE
+-- The remainder of this file is generated from IDL files using domconv-webkit-jsffi
+-- | Functions for this inteface are in "GHCJS.DOM.ANGLEInstancedArrays".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/ANGLEInstancedArrays Mozilla ANGLEInstancedArrays documentation>
+newtype ANGLEInstancedArrays = ANGLEInstancedArrays { unANGLEInstancedArrays :: JSVal }
+
+instance Eq (ANGLEInstancedArrays) where
+  (ANGLEInstancedArrays a) == (ANGLEInstancedArrays b) = js_eq a b
+
+instance PToJSVal ANGLEInstancedArrays where
+  pToJSVal = unANGLEInstancedArrays
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal ANGLEInstancedArrays where
+  pFromJSVal = ANGLEInstancedArrays
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal ANGLEInstancedArrays where
+  toJSVal = return . unANGLEInstancedArrays
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal ANGLEInstancedArrays where
+  fromJSVal = return . fmap ANGLEInstancedArrays . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject ANGLEInstancedArrays where
+  typeGType _ = gTypeANGLEInstancedArrays
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"ANGLEInstancedArrays\"]" gTypeANGLEInstancedArrays :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.AbstractView".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/AbstractView Mozilla AbstractView documentation>
+newtype AbstractView = AbstractView { unAbstractView :: JSVal }
+
+instance Eq (AbstractView) where
+  (AbstractView a) == (AbstractView b) = js_eq a b
+
+instance PToJSVal AbstractView where
+  pToJSVal = unAbstractView
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal AbstractView where
+  pFromJSVal = AbstractView
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal AbstractView where
+  toJSVal = return . unAbstractView
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal AbstractView where
+  fromJSVal = return . fmap AbstractView . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject AbstractView where
+  typeGType _ = gTypeAbstractView
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"AbstractView\"]" gTypeAbstractView :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.AbstractWorker".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/AbstractWorker Mozilla AbstractWorker documentation>
+newtype AbstractWorker = AbstractWorker { unAbstractWorker :: JSVal }
+
+instance Eq (AbstractWorker) where
+  (AbstractWorker a) == (AbstractWorker b) = js_eq a b
+
+instance PToJSVal AbstractWorker where
+  pToJSVal = unAbstractWorker
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal AbstractWorker where
+  pFromJSVal = AbstractWorker
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal AbstractWorker where
+  toJSVal = return . unAbstractWorker
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal AbstractWorker where
+  fromJSVal = return . fmap AbstractWorker . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject AbstractWorker where
+  typeGType _ = gTypeAbstractWorker
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"AbstractWorker\"]" gTypeAbstractWorker :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.AllAudioCapabilities".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.MediaStreamCapabilities"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/AllAudioCapabilities Mozilla AllAudioCapabilities documentation>
+newtype AllAudioCapabilities = AllAudioCapabilities { unAllAudioCapabilities :: JSVal }
+
+instance Eq (AllAudioCapabilities) where
+  (AllAudioCapabilities a) == (AllAudioCapabilities b) = js_eq a b
+
+instance PToJSVal AllAudioCapabilities where
+  pToJSVal = unAllAudioCapabilities
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal AllAudioCapabilities where
+  pFromJSVal = AllAudioCapabilities
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal AllAudioCapabilities where
+  toJSVal = return . unAllAudioCapabilities
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal AllAudioCapabilities where
+  fromJSVal = return . fmap AllAudioCapabilities . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsMediaStreamCapabilities AllAudioCapabilities
+instance IsGObject AllAudioCapabilities where
+  typeGType _ = gTypeAllAudioCapabilities
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"AllAudioCapabilities\"]" gTypeAllAudioCapabilities :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.AllVideoCapabilities".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.MediaStreamCapabilities"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/AllVideoCapabilities Mozilla AllVideoCapabilities documentation>
+newtype AllVideoCapabilities = AllVideoCapabilities { unAllVideoCapabilities :: JSVal }
+
+instance Eq (AllVideoCapabilities) where
+  (AllVideoCapabilities a) == (AllVideoCapabilities b) = js_eq a b
+
+instance PToJSVal AllVideoCapabilities where
+  pToJSVal = unAllVideoCapabilities
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal AllVideoCapabilities where
+  pFromJSVal = AllVideoCapabilities
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal AllVideoCapabilities where
+  toJSVal = return . unAllVideoCapabilities
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal AllVideoCapabilities where
+  fromJSVal = return . fmap AllVideoCapabilities . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsMediaStreamCapabilities AllVideoCapabilities
+instance IsGObject AllVideoCapabilities where
+  typeGType _ = gTypeAllVideoCapabilities
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"AllVideoCapabilities\"]" gTypeAllVideoCapabilities :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.AnalyserNode".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.AudioNode"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/AnalyserNode Mozilla AnalyserNode documentation>
+newtype AnalyserNode = AnalyserNode { unAnalyserNode :: JSVal }
+
+instance Eq (AnalyserNode) where
+  (AnalyserNode a) == (AnalyserNode b) = js_eq a b
+
+instance PToJSVal AnalyserNode where
+  pToJSVal = unAnalyserNode
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal AnalyserNode where
+  pFromJSVal = AnalyserNode
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal AnalyserNode where
+  toJSVal = return . unAnalyserNode
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal AnalyserNode where
+  fromJSVal = return . fmap AnalyserNode . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsAudioNode AnalyserNode
+instance IsEventTarget AnalyserNode
+instance IsGObject AnalyserNode where
+  typeGType _ = gTypeAnalyserNode
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"AnalyserNode\"]" gTypeAnalyserNode :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.AnimationEvent".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.Event"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/AnimationEvent Mozilla AnimationEvent documentation>
+newtype AnimationEvent = AnimationEvent { unAnimationEvent :: JSVal }
+
+instance Eq (AnimationEvent) where
+  (AnimationEvent a) == (AnimationEvent b) = js_eq a b
+
+instance PToJSVal AnimationEvent where
+  pToJSVal = unAnimationEvent
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal AnimationEvent where
+  pFromJSVal = AnimationEvent
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal AnimationEvent where
+  toJSVal = return . unAnimationEvent
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal AnimationEvent where
+  fromJSVal = return . fmap AnimationEvent . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsEvent AnimationEvent
+instance IsGObject AnimationEvent where
+  typeGType _ = gTypeAnimationEvent
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"AnimationEvent\"]" gTypeAnimationEvent :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.ApplicationCache".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/ApplicationCache Mozilla ApplicationCache documentation>
+newtype ApplicationCache = ApplicationCache { unApplicationCache :: JSVal }
+
+instance Eq (ApplicationCache) where
+  (ApplicationCache a) == (ApplicationCache b) = js_eq a b
+
+instance PToJSVal ApplicationCache where
+  pToJSVal = unApplicationCache
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal ApplicationCache where
+  pFromJSVal = ApplicationCache
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal ApplicationCache where
+  toJSVal = return . unApplicationCache
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal ApplicationCache where
+  fromJSVal = return . fmap ApplicationCache . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsEventTarget ApplicationCache
+instance IsGObject ApplicationCache where
+  typeGType _ = gTypeApplicationCache
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"ApplicationCache\"]" gTypeApplicationCache :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.Attr".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/Attr Mozilla Attr documentation>
+newtype Attr = Attr { unAttr :: JSVal }
+
+instance Eq (Attr) where
+  (Attr a) == (Attr b) = js_eq a b
+
+instance PToJSVal Attr where
+  pToJSVal = unAttr
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal Attr where
+  pFromJSVal = Attr
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal Attr where
+  toJSVal = return . unAttr
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal Attr where
+  fromJSVal = return . fmap Attr . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsNode Attr
+instance IsEventTarget Attr
+instance IsGObject Attr where
+  typeGType _ = gTypeAttr
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"Attr\"]" gTypeAttr :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.AudioBuffer".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/AudioBuffer Mozilla AudioBuffer documentation>
+newtype AudioBuffer = AudioBuffer { unAudioBuffer :: JSVal }
+
+instance Eq (AudioBuffer) where
+  (AudioBuffer a) == (AudioBuffer b) = js_eq a b
+
+instance PToJSVal AudioBuffer where
+  pToJSVal = unAudioBuffer
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal AudioBuffer where
+  pFromJSVal = AudioBuffer
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal AudioBuffer where
+  toJSVal = return . unAudioBuffer
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal AudioBuffer where
+  fromJSVal = return . fmap AudioBuffer . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject AudioBuffer where
+  typeGType _ = gTypeAudioBuffer
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"AudioBuffer\"]" gTypeAudioBuffer :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.AudioBufferSourceNode".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.AudioNode"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/AudioBufferSourceNode Mozilla AudioBufferSourceNode documentation>
+newtype AudioBufferSourceNode = AudioBufferSourceNode { unAudioBufferSourceNode :: JSVal }
+
+instance Eq (AudioBufferSourceNode) where
+  (AudioBufferSourceNode a) == (AudioBufferSourceNode b) = js_eq a b
+
+instance PToJSVal AudioBufferSourceNode where
+  pToJSVal = unAudioBufferSourceNode
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal AudioBufferSourceNode where
+  pFromJSVal = AudioBufferSourceNode
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal AudioBufferSourceNode where
+  toJSVal = return . unAudioBufferSourceNode
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal AudioBufferSourceNode where
+  fromJSVal = return . fmap AudioBufferSourceNode . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsAudioNode AudioBufferSourceNode
+instance IsEventTarget AudioBufferSourceNode
+instance IsGObject AudioBufferSourceNode where
+  typeGType _ = gTypeAudioBufferSourceNode
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"AudioBufferSourceNode\"]" gTypeAudioBufferSourceNode :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.AudioContext".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/AudioContext Mozilla AudioContext documentation>
+newtype AudioContext = AudioContext { unAudioContext :: JSVal }
+
+instance Eq (AudioContext) where
+  (AudioContext a) == (AudioContext b) = js_eq a b
+
+instance PToJSVal AudioContext where
+  pToJSVal = unAudioContext
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal AudioContext where
+  pFromJSVal = AudioContext
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal AudioContext where
+  toJSVal = return . unAudioContext
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal AudioContext where
+  fromJSVal = return . fmap AudioContext . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+class IsEventTarget o => IsAudioContext o
+toAudioContext :: IsAudioContext o => o -> AudioContext
+toAudioContext = AudioContext . coerce
+
+instance IsAudioContext AudioContext
+instance IsEventTarget AudioContext
+instance IsGObject AudioContext where
+  typeGType _ = gTypeAudioContext
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"AudioContext\"]" gTypeAudioContext :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.AudioDestinationNode".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.AudioNode"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/AudioDestinationNode Mozilla AudioDestinationNode documentation>
+newtype AudioDestinationNode = AudioDestinationNode { unAudioDestinationNode :: JSVal }
+
+instance Eq (AudioDestinationNode) where
+  (AudioDestinationNode a) == (AudioDestinationNode b) = js_eq a b
+
+instance PToJSVal AudioDestinationNode where
+  pToJSVal = unAudioDestinationNode
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal AudioDestinationNode where
+  pFromJSVal = AudioDestinationNode
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal AudioDestinationNode where
+  toJSVal = return . unAudioDestinationNode
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal AudioDestinationNode where
+  fromJSVal = return . fmap AudioDestinationNode . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsAudioNode AudioDestinationNode
+instance IsEventTarget AudioDestinationNode
+instance IsGObject AudioDestinationNode where
+  typeGType _ = gTypeAudioDestinationNode
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"AudioDestinationNode\"]" gTypeAudioDestinationNode :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.AudioListener".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/AudioListener Mozilla AudioListener documentation>
+newtype AudioListener = AudioListener { unAudioListener :: JSVal }
+
+instance Eq (AudioListener) where
+  (AudioListener a) == (AudioListener b) = js_eq a b
+
+instance PToJSVal AudioListener where
+  pToJSVal = unAudioListener
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal AudioListener where
+  pFromJSVal = AudioListener
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal AudioListener where
+  toJSVal = return . unAudioListener
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal AudioListener where
+  fromJSVal = return . fmap AudioListener . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject AudioListener where
+  typeGType _ = gTypeAudioListener
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"AudioListener\"]" gTypeAudioListener :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.AudioNode".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/AudioNode Mozilla AudioNode documentation>
+newtype AudioNode = AudioNode { unAudioNode :: JSVal }
+
+instance Eq (AudioNode) where
+  (AudioNode a) == (AudioNode b) = js_eq a b
+
+instance PToJSVal AudioNode where
+  pToJSVal = unAudioNode
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal AudioNode where
+  pFromJSVal = AudioNode
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal AudioNode where
+  toJSVal = return . unAudioNode
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal AudioNode where
+  fromJSVal = return . fmap AudioNode . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+class IsEventTarget o => IsAudioNode o
+toAudioNode :: IsAudioNode o => o -> AudioNode
+toAudioNode = AudioNode . coerce
+
+instance IsAudioNode AudioNode
+instance IsEventTarget AudioNode
+instance IsGObject AudioNode where
+  typeGType _ = gTypeAudioNode
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"AudioNode\"]" gTypeAudioNode :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.AudioParam".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/AudioParam Mozilla AudioParam documentation>
+newtype AudioParam = AudioParam { unAudioParam :: JSVal }
+
+instance Eq (AudioParam) where
+  (AudioParam a) == (AudioParam b) = js_eq a b
+
+instance PToJSVal AudioParam where
+  pToJSVal = unAudioParam
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal AudioParam where
+  pFromJSVal = AudioParam
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal AudioParam where
+  toJSVal = return . unAudioParam
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal AudioParam where
+  fromJSVal = return . fmap AudioParam . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject AudioParam where
+  typeGType _ = gTypeAudioParam
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"AudioParam\"]" gTypeAudioParam :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.AudioProcessingEvent".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.Event"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/AudioProcessingEvent Mozilla AudioProcessingEvent documentation>
+newtype AudioProcessingEvent = AudioProcessingEvent { unAudioProcessingEvent :: JSVal }
+
+instance Eq (AudioProcessingEvent) where
+  (AudioProcessingEvent a) == (AudioProcessingEvent b) = js_eq a b
+
+instance PToJSVal AudioProcessingEvent where
+  pToJSVal = unAudioProcessingEvent
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal AudioProcessingEvent where
+  pFromJSVal = AudioProcessingEvent
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal AudioProcessingEvent where
+  toJSVal = return . unAudioProcessingEvent
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal AudioProcessingEvent where
+  fromJSVal = return . fmap AudioProcessingEvent . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsEvent AudioProcessingEvent
+instance IsGObject AudioProcessingEvent where
+  typeGType _ = gTypeAudioProcessingEvent
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"AudioProcessingEvent\"]" gTypeAudioProcessingEvent :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.AudioStreamTrack".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.MediaStreamTrack"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/AudioStreamTrack Mozilla AudioStreamTrack documentation>
+newtype AudioStreamTrack = AudioStreamTrack { unAudioStreamTrack :: JSVal }
+
+instance Eq (AudioStreamTrack) where
+  (AudioStreamTrack a) == (AudioStreamTrack b) = js_eq a b
+
+instance PToJSVal AudioStreamTrack where
+  pToJSVal = unAudioStreamTrack
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal AudioStreamTrack where
+  pFromJSVal = AudioStreamTrack
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal AudioStreamTrack where
+  toJSVal = return . unAudioStreamTrack
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal AudioStreamTrack where
+  fromJSVal = return . fmap AudioStreamTrack . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsMediaStreamTrack AudioStreamTrack
+instance IsEventTarget AudioStreamTrack
+instance IsGObject AudioStreamTrack where
+  typeGType _ = gTypeAudioStreamTrack
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"AudioStreamTrack\"]" gTypeAudioStreamTrack :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.AudioTrack".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/AudioTrack Mozilla AudioTrack documentation>
+newtype AudioTrack = AudioTrack { unAudioTrack :: JSVal }
+
+instance Eq (AudioTrack) where
+  (AudioTrack a) == (AudioTrack b) = js_eq a b
+
+instance PToJSVal AudioTrack where
+  pToJSVal = unAudioTrack
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal AudioTrack where
+  pFromJSVal = AudioTrack
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal AudioTrack where
+  toJSVal = return . unAudioTrack
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal AudioTrack where
+  fromJSVal = return . fmap AudioTrack . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject AudioTrack where
+  typeGType _ = gTypeAudioTrack
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"AudioTrack\"]" gTypeAudioTrack :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.AudioTrackList".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/AudioTrackList Mozilla AudioTrackList documentation>
+newtype AudioTrackList = AudioTrackList { unAudioTrackList :: JSVal }
+
+instance Eq (AudioTrackList) where
+  (AudioTrackList a) == (AudioTrackList b) = js_eq a b
+
+instance PToJSVal AudioTrackList where
+  pToJSVal = unAudioTrackList
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal AudioTrackList where
+  pFromJSVal = AudioTrackList
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal AudioTrackList where
+  toJSVal = return . unAudioTrackList
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal AudioTrackList where
+  fromJSVal = return . fmap AudioTrackList . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsEventTarget AudioTrackList
+instance IsGObject AudioTrackList where
+  typeGType _ = gTypeAudioTrackList
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"AudioTrackList\"]" gTypeAudioTrackList :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.AutocompleteErrorEvent".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.Event"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/AutocompleteErrorEvent Mozilla AutocompleteErrorEvent documentation>
+newtype AutocompleteErrorEvent = AutocompleteErrorEvent { unAutocompleteErrorEvent :: JSVal }
+
+instance Eq (AutocompleteErrorEvent) where
+  (AutocompleteErrorEvent a) == (AutocompleteErrorEvent b) = js_eq a b
+
+instance PToJSVal AutocompleteErrorEvent where
+  pToJSVal = unAutocompleteErrorEvent
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal AutocompleteErrorEvent where
+  pFromJSVal = AutocompleteErrorEvent
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal AutocompleteErrorEvent where
+  toJSVal = return . unAutocompleteErrorEvent
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal AutocompleteErrorEvent where
+  fromJSVal = return . fmap AutocompleteErrorEvent . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsEvent AutocompleteErrorEvent
+instance IsGObject AutocompleteErrorEvent where
+  typeGType _ = gTypeAutocompleteErrorEvent
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"AutocompleteErrorEvent\"]" gTypeAutocompleteErrorEvent :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.BarProp".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/BarProp Mozilla BarProp documentation>
+newtype BarProp = BarProp { unBarProp :: JSVal }
+
+instance Eq (BarProp) where
+  (BarProp a) == (BarProp b) = js_eq a b
+
+instance PToJSVal BarProp where
+  pToJSVal = unBarProp
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal BarProp where
+  pFromJSVal = BarProp
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal BarProp where
+  toJSVal = return . unBarProp
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal BarProp where
+  fromJSVal = return . fmap BarProp . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject BarProp where
+  typeGType _ = gTypeBarProp
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"BarProp\"]" gTypeBarProp :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.BatteryManager".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/BatteryManager Mozilla BatteryManager documentation>
+newtype BatteryManager = BatteryManager { unBatteryManager :: JSVal }
+
+instance Eq (BatteryManager) where
+  (BatteryManager a) == (BatteryManager b) = js_eq a b
+
+instance PToJSVal BatteryManager where
+  pToJSVal = unBatteryManager
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal BatteryManager where
+  pFromJSVal = BatteryManager
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal BatteryManager where
+  toJSVal = return . unBatteryManager
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal BatteryManager where
+  fromJSVal = return . fmap BatteryManager . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsEventTarget BatteryManager
+instance IsGObject BatteryManager where
+  typeGType _ = gTypeBatteryManager
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"BatteryManager\"]" gTypeBatteryManager :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.BeforeLoadEvent".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.Event"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/BeforeLoadEvent Mozilla BeforeLoadEvent documentation>
+newtype BeforeLoadEvent = BeforeLoadEvent { unBeforeLoadEvent :: JSVal }
+
+instance Eq (BeforeLoadEvent) where
+  (BeforeLoadEvent a) == (BeforeLoadEvent b) = js_eq a b
+
+instance PToJSVal BeforeLoadEvent where
+  pToJSVal = unBeforeLoadEvent
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal BeforeLoadEvent where
+  pFromJSVal = BeforeLoadEvent
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal BeforeLoadEvent where
+  toJSVal = return . unBeforeLoadEvent
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal BeforeLoadEvent where
+  fromJSVal = return . fmap BeforeLoadEvent . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsEvent BeforeLoadEvent
+instance IsGObject BeforeLoadEvent where
+  typeGType _ = gTypeBeforeLoadEvent
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"BeforeLoadEvent\"]" gTypeBeforeLoadEvent :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.BeforeUnloadEvent".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.Event"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/BeforeUnloadEvent Mozilla BeforeUnloadEvent documentation>
+newtype BeforeUnloadEvent = BeforeUnloadEvent { unBeforeUnloadEvent :: JSVal }
+
+instance Eq (BeforeUnloadEvent) where
+  (BeforeUnloadEvent a) == (BeforeUnloadEvent b) = js_eq a b
+
+instance PToJSVal BeforeUnloadEvent where
+  pToJSVal = unBeforeUnloadEvent
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal BeforeUnloadEvent where
+  pFromJSVal = BeforeUnloadEvent
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal BeforeUnloadEvent where
+  toJSVal = return . unBeforeUnloadEvent
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal BeforeUnloadEvent where
+  fromJSVal = return . fmap BeforeUnloadEvent . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsEvent BeforeUnloadEvent
+instance IsGObject BeforeUnloadEvent where
+  typeGType _ = gTypeBeforeUnloadEvent
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"BeforeUnloadEvent\"]" gTypeBeforeUnloadEvent :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.BiquadFilterNode".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.AudioNode"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/BiquadFilterNode Mozilla BiquadFilterNode documentation>
+newtype BiquadFilterNode = BiquadFilterNode { unBiquadFilterNode :: JSVal }
+
+instance Eq (BiquadFilterNode) where
+  (BiquadFilterNode a) == (BiquadFilterNode b) = js_eq a b
+
+instance PToJSVal BiquadFilterNode where
+  pToJSVal = unBiquadFilterNode
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal BiquadFilterNode where
+  pFromJSVal = BiquadFilterNode
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal BiquadFilterNode where
+  toJSVal = return . unBiquadFilterNode
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal BiquadFilterNode where
+  fromJSVal = return . fmap BiquadFilterNode . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsAudioNode BiquadFilterNode
+instance IsEventTarget BiquadFilterNode
+instance IsGObject BiquadFilterNode where
+  typeGType _ = gTypeBiquadFilterNode
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"BiquadFilterNode\"]" gTypeBiquadFilterNode :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.Blob".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/Blob Mozilla Blob documentation>
+newtype Blob = Blob { unBlob :: JSVal }
+
+instance Eq (Blob) where
+  (Blob a) == (Blob b) = js_eq a b
+
+instance PToJSVal Blob where
+  pToJSVal = unBlob
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal Blob where
+  pFromJSVal = Blob
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal Blob where
+  toJSVal = return . unBlob
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal Blob where
+  fromJSVal = return . fmap Blob . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+class IsGObject o => IsBlob o
+toBlob :: IsBlob o => o -> Blob
+toBlob = Blob . coerce
+
+instance IsBlob Blob
+instance IsGObject Blob where
+  typeGType _ = gTypeBlob
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"Blob\"]" gTypeBlob :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.CDATASection".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.Text"
+--     * "GHCJS.DOM.CharacterData"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/CDATASection Mozilla CDATASection documentation>
+newtype CDATASection = CDATASection { unCDATASection :: JSVal }
+
+instance Eq (CDATASection) where
+  (CDATASection a) == (CDATASection b) = js_eq a b
+
+instance PToJSVal CDATASection where
+  pToJSVal = unCDATASection
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal CDATASection where
+  pFromJSVal = CDATASection
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal CDATASection where
+  toJSVal = return . unCDATASection
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal CDATASection where
+  fromJSVal = return . fmap CDATASection . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsText CDATASection
+instance IsCharacterData CDATASection
+instance IsNode CDATASection
+instance IsEventTarget CDATASection
+instance IsGObject CDATASection where
+  typeGType _ = gTypeCDATASection
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"CDATASection\"]" gTypeCDATASection :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.CSS".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/CSS Mozilla CSS documentation>
+newtype CSS = CSS { unCSS :: JSVal }
+
+instance Eq (CSS) where
+  (CSS a) == (CSS b) = js_eq a b
+
+instance PToJSVal CSS where
+  pToJSVal = unCSS
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal CSS where
+  pFromJSVal = CSS
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal CSS where
+  toJSVal = return . unCSS
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal CSS where
+  fromJSVal = return . fmap CSS . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject CSS where
+  typeGType _ = gTypeCSS
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"CSS\"]" gTypeCSS :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.CSSCharsetRule".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.CSSRule"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/CSSCharsetRule Mozilla CSSCharsetRule documentation>
+newtype CSSCharsetRule = CSSCharsetRule { unCSSCharsetRule :: JSVal }
+
+instance Eq (CSSCharsetRule) where
+  (CSSCharsetRule a) == (CSSCharsetRule b) = js_eq a b
+
+instance PToJSVal CSSCharsetRule where
+  pToJSVal = unCSSCharsetRule
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal CSSCharsetRule where
+  pFromJSVal = CSSCharsetRule
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal CSSCharsetRule where
+  toJSVal = return . unCSSCharsetRule
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal CSSCharsetRule where
+  fromJSVal = return . fmap CSSCharsetRule . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsCSSRule CSSCharsetRule
+instance IsGObject CSSCharsetRule where
+  typeGType _ = gTypeCSSCharsetRule
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"CSSCharsetRule\"]" gTypeCSSCharsetRule :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.CSSFontFaceLoadEvent".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.Event"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/CSSFontFaceLoadEvent Mozilla CSSFontFaceLoadEvent documentation>
+newtype CSSFontFaceLoadEvent = CSSFontFaceLoadEvent { unCSSFontFaceLoadEvent :: JSVal }
+
+instance Eq (CSSFontFaceLoadEvent) where
+  (CSSFontFaceLoadEvent a) == (CSSFontFaceLoadEvent b) = js_eq a b
+
+instance PToJSVal CSSFontFaceLoadEvent where
+  pToJSVal = unCSSFontFaceLoadEvent
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal CSSFontFaceLoadEvent where
+  pFromJSVal = CSSFontFaceLoadEvent
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal CSSFontFaceLoadEvent where
+  toJSVal = return . unCSSFontFaceLoadEvent
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal CSSFontFaceLoadEvent where
+  fromJSVal = return . fmap CSSFontFaceLoadEvent . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsEvent CSSFontFaceLoadEvent
+instance IsGObject CSSFontFaceLoadEvent where
+  typeGType _ = gTypeCSSFontFaceLoadEvent
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"CSSFontFaceLoadEvent\"]" gTypeCSSFontFaceLoadEvent :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.CSSFontFaceRule".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.CSSRule"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/CSSFontFaceRule Mozilla CSSFontFaceRule documentation>
+newtype CSSFontFaceRule = CSSFontFaceRule { unCSSFontFaceRule :: JSVal }
+
+instance Eq (CSSFontFaceRule) where
+  (CSSFontFaceRule a) == (CSSFontFaceRule b) = js_eq a b
+
+instance PToJSVal CSSFontFaceRule where
+  pToJSVal = unCSSFontFaceRule
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal CSSFontFaceRule where
+  pFromJSVal = CSSFontFaceRule
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal CSSFontFaceRule where
+  toJSVal = return . unCSSFontFaceRule
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal CSSFontFaceRule where
+  fromJSVal = return . fmap CSSFontFaceRule . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsCSSRule CSSFontFaceRule
+instance IsGObject CSSFontFaceRule where
+  typeGType _ = gTypeCSSFontFaceRule
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"CSSFontFaceRule\"]" gTypeCSSFontFaceRule :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.CSSImportRule".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.CSSRule"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/CSSImportRule Mozilla CSSImportRule documentation>
+newtype CSSImportRule = CSSImportRule { unCSSImportRule :: JSVal }
+
+instance Eq (CSSImportRule) where
+  (CSSImportRule a) == (CSSImportRule b) = js_eq a b
+
+instance PToJSVal CSSImportRule where
+  pToJSVal = unCSSImportRule
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal CSSImportRule where
+  pFromJSVal = CSSImportRule
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal CSSImportRule where
+  toJSVal = return . unCSSImportRule
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal CSSImportRule where
+  fromJSVal = return . fmap CSSImportRule . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsCSSRule CSSImportRule
+instance IsGObject CSSImportRule where
+  typeGType _ = gTypeCSSImportRule
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"CSSImportRule\"]" gTypeCSSImportRule :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.CSSKeyframeRule".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.CSSRule"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/CSSKeyframeRule Mozilla CSSKeyframeRule documentation>
+newtype CSSKeyframeRule = CSSKeyframeRule { unCSSKeyframeRule :: JSVal }
+
+instance Eq (CSSKeyframeRule) where
+  (CSSKeyframeRule a) == (CSSKeyframeRule b) = js_eq a b
+
+instance PToJSVal CSSKeyframeRule where
+  pToJSVal = unCSSKeyframeRule
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal CSSKeyframeRule where
+  pFromJSVal = CSSKeyframeRule
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal CSSKeyframeRule where
+  toJSVal = return . unCSSKeyframeRule
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal CSSKeyframeRule where
+  fromJSVal = return . fmap CSSKeyframeRule . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsCSSRule CSSKeyframeRule
+instance IsGObject CSSKeyframeRule where
+  typeGType _ = gTypeCSSKeyframeRule
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"CSSKeyframeRule\"]" gTypeCSSKeyframeRule :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.CSSKeyframesRule".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.CSSRule"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/CSSKeyframesRule Mozilla CSSKeyframesRule documentation>
+newtype CSSKeyframesRule = CSSKeyframesRule { unCSSKeyframesRule :: JSVal }
+
+instance Eq (CSSKeyframesRule) where
+  (CSSKeyframesRule a) == (CSSKeyframesRule b) = js_eq a b
+
+instance PToJSVal CSSKeyframesRule where
+  pToJSVal = unCSSKeyframesRule
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal CSSKeyframesRule where
+  pFromJSVal = CSSKeyframesRule
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal CSSKeyframesRule where
+  toJSVal = return . unCSSKeyframesRule
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal CSSKeyframesRule where
+  fromJSVal = return . fmap CSSKeyframesRule . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsCSSRule CSSKeyframesRule
+instance IsGObject CSSKeyframesRule where
+  typeGType _ = gTypeCSSKeyframesRule
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"CSSKeyframesRule\"]" gTypeCSSKeyframesRule :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.CSSMediaRule".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.CSSRule"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/CSSMediaRule Mozilla CSSMediaRule documentation>
+newtype CSSMediaRule = CSSMediaRule { unCSSMediaRule :: JSVal }
+
+instance Eq (CSSMediaRule) where
+  (CSSMediaRule a) == (CSSMediaRule b) = js_eq a b
+
+instance PToJSVal CSSMediaRule where
+  pToJSVal = unCSSMediaRule
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal CSSMediaRule where
+  pFromJSVal = CSSMediaRule
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal CSSMediaRule where
+  toJSVal = return . unCSSMediaRule
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal CSSMediaRule where
+  fromJSVal = return . fmap CSSMediaRule . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsCSSRule CSSMediaRule
+instance IsGObject CSSMediaRule where
+  typeGType _ = gTypeCSSMediaRule
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"CSSMediaRule\"]" gTypeCSSMediaRule :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.CSSPageRule".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.CSSRule"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/CSSPageRule Mozilla CSSPageRule documentation>
+newtype CSSPageRule = CSSPageRule { unCSSPageRule :: JSVal }
+
+instance Eq (CSSPageRule) where
+  (CSSPageRule a) == (CSSPageRule b) = js_eq a b
+
+instance PToJSVal CSSPageRule where
+  pToJSVal = unCSSPageRule
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal CSSPageRule where
+  pFromJSVal = CSSPageRule
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal CSSPageRule where
+  toJSVal = return . unCSSPageRule
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal CSSPageRule where
+  fromJSVal = return . fmap CSSPageRule . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsCSSRule CSSPageRule
+instance IsGObject CSSPageRule where
+  typeGType _ = gTypeCSSPageRule
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"CSSPageRule\"]" gTypeCSSPageRule :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.CSSPrimitiveValue".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.CSSValue"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/CSSPrimitiveValue Mozilla CSSPrimitiveValue documentation>
+newtype CSSPrimitiveValue = CSSPrimitiveValue { unCSSPrimitiveValue :: JSVal }
+
+instance Eq (CSSPrimitiveValue) where
+  (CSSPrimitiveValue a) == (CSSPrimitiveValue b) = js_eq a b
+
+instance PToJSVal CSSPrimitiveValue where
+  pToJSVal = unCSSPrimitiveValue
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal CSSPrimitiveValue where
+  pFromJSVal = CSSPrimitiveValue
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal CSSPrimitiveValue where
+  toJSVal = return . unCSSPrimitiveValue
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal CSSPrimitiveValue where
+  fromJSVal = return . fmap CSSPrimitiveValue . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsCSSValue CSSPrimitiveValue
+instance IsGObject CSSPrimitiveValue where
+  typeGType _ = gTypeCSSPrimitiveValue
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"CSSPrimitiveValue\"]" gTypeCSSPrimitiveValue :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.CSSRule".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/CSSRule Mozilla CSSRule documentation>
+newtype CSSRule = CSSRule { unCSSRule :: JSVal }
+
+instance Eq (CSSRule) where
+  (CSSRule a) == (CSSRule b) = js_eq a b
+
+instance PToJSVal CSSRule where
+  pToJSVal = unCSSRule
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal CSSRule where
+  pFromJSVal = CSSRule
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal CSSRule where
+  toJSVal = return . unCSSRule
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal CSSRule where
+  fromJSVal = return . fmap CSSRule . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+class IsGObject o => IsCSSRule o
+toCSSRule :: IsCSSRule o => o -> CSSRule
+toCSSRule = CSSRule . coerce
+
+instance IsCSSRule CSSRule
+instance IsGObject CSSRule where
+  typeGType _ = gTypeCSSRule
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"CSSRule\"]" gTypeCSSRule :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.CSSRuleList".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/CSSRuleList Mozilla CSSRuleList documentation>
+newtype CSSRuleList = CSSRuleList { unCSSRuleList :: JSVal }
+
+instance Eq (CSSRuleList) where
+  (CSSRuleList a) == (CSSRuleList b) = js_eq a b
+
+instance PToJSVal CSSRuleList where
+  pToJSVal = unCSSRuleList
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal CSSRuleList where
+  pFromJSVal = CSSRuleList
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal CSSRuleList where
+  toJSVal = return . unCSSRuleList
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal CSSRuleList where
+  fromJSVal = return . fmap CSSRuleList . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject CSSRuleList where
+  typeGType _ = gTypeCSSRuleList
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"CSSRuleList\"]" gTypeCSSRuleList :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.CSSStyleDeclaration".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/CSSStyleDeclaration Mozilla CSSStyleDeclaration documentation>
+newtype CSSStyleDeclaration = CSSStyleDeclaration { unCSSStyleDeclaration :: JSVal }
+
+instance Eq (CSSStyleDeclaration) where
+  (CSSStyleDeclaration a) == (CSSStyleDeclaration b) = js_eq a b
+
+instance PToJSVal CSSStyleDeclaration where
+  pToJSVal = unCSSStyleDeclaration
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal CSSStyleDeclaration where
+  pFromJSVal = CSSStyleDeclaration
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal CSSStyleDeclaration where
+  toJSVal = return . unCSSStyleDeclaration
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal CSSStyleDeclaration where
+  fromJSVal = return . fmap CSSStyleDeclaration . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject CSSStyleDeclaration where
+  typeGType _ = gTypeCSSStyleDeclaration
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"CSSStyleDeclaration\"]" gTypeCSSStyleDeclaration :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.CSSStyleRule".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.CSSRule"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/CSSStyleRule Mozilla CSSStyleRule documentation>
+newtype CSSStyleRule = CSSStyleRule { unCSSStyleRule :: JSVal }
+
+instance Eq (CSSStyleRule) where
+  (CSSStyleRule a) == (CSSStyleRule b) = js_eq a b
+
+instance PToJSVal CSSStyleRule where
+  pToJSVal = unCSSStyleRule
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal CSSStyleRule where
+  pFromJSVal = CSSStyleRule
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal CSSStyleRule where
+  toJSVal = return . unCSSStyleRule
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal CSSStyleRule where
+  fromJSVal = return . fmap CSSStyleRule . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsCSSRule CSSStyleRule
+instance IsGObject CSSStyleRule where
+  typeGType _ = gTypeCSSStyleRule
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"CSSStyleRule\"]" gTypeCSSStyleRule :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.CSSStyleSheet".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.StyleSheet"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/CSSStyleSheet Mozilla CSSStyleSheet documentation>
+newtype CSSStyleSheet = CSSStyleSheet { unCSSStyleSheet :: JSVal }
+
+instance Eq (CSSStyleSheet) where
+  (CSSStyleSheet a) == (CSSStyleSheet b) = js_eq a b
+
+instance PToJSVal CSSStyleSheet where
+  pToJSVal = unCSSStyleSheet
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal CSSStyleSheet where
+  pFromJSVal = CSSStyleSheet
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal CSSStyleSheet where
+  toJSVal = return . unCSSStyleSheet
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal CSSStyleSheet where
+  fromJSVal = return . fmap CSSStyleSheet . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsStyleSheet CSSStyleSheet
+instance IsGObject CSSStyleSheet where
+  typeGType _ = gTypeCSSStyleSheet
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"CSSStyleSheet\"]" gTypeCSSStyleSheet :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.CSSSupportsRule".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.CSSRule"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/CSSSupportsRule Mozilla CSSSupportsRule documentation>
+newtype CSSSupportsRule = CSSSupportsRule { unCSSSupportsRule :: JSVal }
+
+instance Eq (CSSSupportsRule) where
+  (CSSSupportsRule a) == (CSSSupportsRule b) = js_eq a b
+
+instance PToJSVal CSSSupportsRule where
+  pToJSVal = unCSSSupportsRule
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal CSSSupportsRule where
+  pFromJSVal = CSSSupportsRule
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal CSSSupportsRule where
+  toJSVal = return . unCSSSupportsRule
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal CSSSupportsRule where
+  fromJSVal = return . fmap CSSSupportsRule . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsCSSRule CSSSupportsRule
+instance IsGObject CSSSupportsRule where
+  typeGType _ = gTypeCSSSupportsRule
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"CSSSupportsRule\"]" gTypeCSSSupportsRule :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.CSSUnknownRule".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.CSSRule"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/CSSUnknownRule Mozilla CSSUnknownRule documentation>
+newtype CSSUnknownRule = CSSUnknownRule { unCSSUnknownRule :: JSVal }
+
+instance Eq (CSSUnknownRule) where
+  (CSSUnknownRule a) == (CSSUnknownRule b) = js_eq a b
+
+instance PToJSVal CSSUnknownRule where
+  pToJSVal = unCSSUnknownRule
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal CSSUnknownRule where
+  pFromJSVal = CSSUnknownRule
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal CSSUnknownRule where
+  toJSVal = return . unCSSUnknownRule
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal CSSUnknownRule where
+  fromJSVal = return . fmap CSSUnknownRule . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsCSSRule CSSUnknownRule
+instance IsGObject CSSUnknownRule where
+  typeGType _ = gTypeCSSUnknownRule
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"CSSUnknownRule\"]" gTypeCSSUnknownRule :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.CSSValue".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/CSSValue Mozilla CSSValue documentation>
+newtype CSSValue = CSSValue { unCSSValue :: JSVal }
+
+instance Eq (CSSValue) where
+  (CSSValue a) == (CSSValue b) = js_eq a b
+
+instance PToJSVal CSSValue where
+  pToJSVal = unCSSValue
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal CSSValue where
+  pFromJSVal = CSSValue
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal CSSValue where
+  toJSVal = return . unCSSValue
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal CSSValue where
+  fromJSVal = return . fmap CSSValue . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+class IsGObject o => IsCSSValue o
+toCSSValue :: IsCSSValue o => o -> CSSValue
+toCSSValue = CSSValue . coerce
+
+instance IsCSSValue CSSValue
+instance IsGObject CSSValue where
+  typeGType _ = gTypeCSSValue
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"CSSValue\"]" gTypeCSSValue :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.CSSValueList".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.CSSValue"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/CSSValueList Mozilla CSSValueList documentation>
+newtype CSSValueList = CSSValueList { unCSSValueList :: JSVal }
+
+instance Eq (CSSValueList) where
+  (CSSValueList a) == (CSSValueList b) = js_eq a b
+
+instance PToJSVal CSSValueList where
+  pToJSVal = unCSSValueList
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal CSSValueList where
+  pFromJSVal = CSSValueList
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal CSSValueList where
+  toJSVal = return . unCSSValueList
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal CSSValueList where
+  fromJSVal = return . fmap CSSValueList . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+class IsCSSValue o => IsCSSValueList o
+toCSSValueList :: IsCSSValueList o => o -> CSSValueList
+toCSSValueList = CSSValueList . coerce
+
+instance IsCSSValueList CSSValueList
+instance IsCSSValue CSSValueList
+instance IsGObject CSSValueList where
+  typeGType _ = gTypeCSSValueList
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"CSSValueList\"]" gTypeCSSValueList :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.CanvasGradient".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/CanvasGradient Mozilla CanvasGradient documentation>
+newtype CanvasGradient = CanvasGradient { unCanvasGradient :: JSVal }
+
+instance Eq (CanvasGradient) where
+  (CanvasGradient a) == (CanvasGradient b) = js_eq a b
+
+instance PToJSVal CanvasGradient where
+  pToJSVal = unCanvasGradient
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal CanvasGradient where
+  pFromJSVal = CanvasGradient
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal CanvasGradient where
+  toJSVal = return . unCanvasGradient
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal CanvasGradient where
+  fromJSVal = return . fmap CanvasGradient . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject CanvasGradient where
+  typeGType _ = gTypeCanvasGradient
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"CanvasGradient\"]" gTypeCanvasGradient :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.CanvasPattern".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/CanvasPattern Mozilla CanvasPattern documentation>
+newtype CanvasPattern = CanvasPattern { unCanvasPattern :: JSVal }
+
+instance Eq (CanvasPattern) where
+  (CanvasPattern a) == (CanvasPattern b) = js_eq a b
+
+instance PToJSVal CanvasPattern where
+  pToJSVal = unCanvasPattern
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal CanvasPattern where
+  pFromJSVal = CanvasPattern
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal CanvasPattern where
+  toJSVal = return . unCanvasPattern
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal CanvasPattern where
+  fromJSVal = return . fmap CanvasPattern . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject CanvasPattern where
+  typeGType _ = gTypeCanvasPattern
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"CanvasPattern\"]" gTypeCanvasPattern :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.CanvasProxy".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/CanvasProxy Mozilla CanvasProxy documentation>
+newtype CanvasProxy = CanvasProxy { unCanvasProxy :: JSVal }
+
+instance Eq (CanvasProxy) where
+  (CanvasProxy a) == (CanvasProxy b) = js_eq a b
+
+instance PToJSVal CanvasProxy where
+  pToJSVal = unCanvasProxy
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal CanvasProxy where
+  pFromJSVal = CanvasProxy
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal CanvasProxy where
+  toJSVal = return . unCanvasProxy
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal CanvasProxy where
+  fromJSVal = return . fmap CanvasProxy . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject CanvasProxy where
+  typeGType _ = gTypeCanvasProxy
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"CanvasProxy\"]" gTypeCanvasProxy :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.CanvasRenderingContext".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/CanvasRenderingContext Mozilla CanvasRenderingContext documentation>
+newtype CanvasRenderingContext = CanvasRenderingContext { unCanvasRenderingContext :: JSVal }
+
+instance Eq (CanvasRenderingContext) where
+  (CanvasRenderingContext a) == (CanvasRenderingContext b) = js_eq a b
+
+instance PToJSVal CanvasRenderingContext where
+  pToJSVal = unCanvasRenderingContext
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal CanvasRenderingContext where
+  pFromJSVal = CanvasRenderingContext
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal CanvasRenderingContext where
+  toJSVal = return . unCanvasRenderingContext
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal CanvasRenderingContext where
+  fromJSVal = return . fmap CanvasRenderingContext . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+class IsGObject o => IsCanvasRenderingContext o
+toCanvasRenderingContext :: IsCanvasRenderingContext o => o -> CanvasRenderingContext
+toCanvasRenderingContext = CanvasRenderingContext . coerce
+
+instance IsCanvasRenderingContext CanvasRenderingContext
+instance IsGObject CanvasRenderingContext where
+  typeGType _ = gTypeCanvasRenderingContext
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"CanvasRenderingContext\"]" gTypeCanvasRenderingContext :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.CanvasRenderingContext2D".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.CanvasRenderingContext"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/CanvasRenderingContext2D Mozilla CanvasRenderingContext2D documentation>
+newtype CanvasRenderingContext2D = CanvasRenderingContext2D { unCanvasRenderingContext2D :: JSVal }
+
+instance Eq (CanvasRenderingContext2D) where
+  (CanvasRenderingContext2D a) == (CanvasRenderingContext2D b) = js_eq a b
+
+instance PToJSVal CanvasRenderingContext2D where
+  pToJSVal = unCanvasRenderingContext2D
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal CanvasRenderingContext2D where
+  pFromJSVal = CanvasRenderingContext2D
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal CanvasRenderingContext2D where
+  toJSVal = return . unCanvasRenderingContext2D
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal CanvasRenderingContext2D where
+  fromJSVal = return . fmap CanvasRenderingContext2D . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsCanvasRenderingContext CanvasRenderingContext2D
+instance IsGObject CanvasRenderingContext2D where
+  typeGType _ = gTypeCanvasRenderingContext2D
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"CanvasRenderingContext2D\"]" gTypeCanvasRenderingContext2D :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.CapabilityRange".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/CapabilityRange Mozilla CapabilityRange documentation>
+newtype CapabilityRange = CapabilityRange { unCapabilityRange :: JSVal }
+
+instance Eq (CapabilityRange) where
+  (CapabilityRange a) == (CapabilityRange b) = js_eq a b
+
+instance PToJSVal CapabilityRange where
+  pToJSVal = unCapabilityRange
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal CapabilityRange where
+  pFromJSVal = CapabilityRange
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal CapabilityRange where
+  toJSVal = return . unCapabilityRange
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal CapabilityRange where
+  fromJSVal = return . fmap CapabilityRange . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject CapabilityRange where
+  typeGType _ = gTypeCapabilityRange
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"CapabilityRange\"]" gTypeCapabilityRange :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.ChannelMergerNode".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.AudioNode"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/ChannelMergerNode Mozilla ChannelMergerNode documentation>
+newtype ChannelMergerNode = ChannelMergerNode { unChannelMergerNode :: JSVal }
+
+instance Eq (ChannelMergerNode) where
+  (ChannelMergerNode a) == (ChannelMergerNode b) = js_eq a b
+
+instance PToJSVal ChannelMergerNode where
+  pToJSVal = unChannelMergerNode
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal ChannelMergerNode where
+  pFromJSVal = ChannelMergerNode
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal ChannelMergerNode where
+  toJSVal = return . unChannelMergerNode
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal ChannelMergerNode where
+  fromJSVal = return . fmap ChannelMergerNode . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsAudioNode ChannelMergerNode
+instance IsEventTarget ChannelMergerNode
+instance IsGObject ChannelMergerNode where
+  typeGType _ = gTypeChannelMergerNode
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"ChannelMergerNode\"]" gTypeChannelMergerNode :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.ChannelSplitterNode".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.AudioNode"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/ChannelSplitterNode Mozilla ChannelSplitterNode documentation>
+newtype ChannelSplitterNode = ChannelSplitterNode { unChannelSplitterNode :: JSVal }
+
+instance Eq (ChannelSplitterNode) where
+  (ChannelSplitterNode a) == (ChannelSplitterNode b) = js_eq a b
+
+instance PToJSVal ChannelSplitterNode where
+  pToJSVal = unChannelSplitterNode
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal ChannelSplitterNode where
+  pFromJSVal = ChannelSplitterNode
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal ChannelSplitterNode where
+  toJSVal = return . unChannelSplitterNode
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal ChannelSplitterNode where
+  fromJSVal = return . fmap ChannelSplitterNode . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsAudioNode ChannelSplitterNode
+instance IsEventTarget ChannelSplitterNode
+instance IsGObject ChannelSplitterNode where
+  typeGType _ = gTypeChannelSplitterNode
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"ChannelSplitterNode\"]" gTypeChannelSplitterNode :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.CharacterData".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/CharacterData Mozilla CharacterData documentation>
+newtype CharacterData = CharacterData { unCharacterData :: JSVal }
+
+instance Eq (CharacterData) where
+  (CharacterData a) == (CharacterData b) = js_eq a b
+
+instance PToJSVal CharacterData where
+  pToJSVal = unCharacterData
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal CharacterData where
+  pFromJSVal = CharacterData
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal CharacterData where
+  toJSVal = return . unCharacterData
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal CharacterData where
+  fromJSVal = return . fmap CharacterData . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+class IsNode o => IsCharacterData o
+toCharacterData :: IsCharacterData o => o -> CharacterData
+toCharacterData = CharacterData . coerce
+
+instance IsCharacterData CharacterData
+instance IsNode CharacterData
+instance IsEventTarget CharacterData
+instance IsGObject CharacterData where
+  typeGType _ = gTypeCharacterData
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"CharacterData\"]" gTypeCharacterData :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.ChildNode".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/ChildNode Mozilla ChildNode documentation>
+newtype ChildNode = ChildNode { unChildNode :: JSVal }
+
+instance Eq (ChildNode) where
+  (ChildNode a) == (ChildNode b) = js_eq a b
+
+instance PToJSVal ChildNode where
+  pToJSVal = unChildNode
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal ChildNode where
+  pFromJSVal = ChildNode
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal ChildNode where
+  toJSVal = return . unChildNode
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal ChildNode where
+  fromJSVal = return . fmap ChildNode . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject ChildNode where
+  typeGType _ = gTypeChildNode
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"ChildNode\"]" gTypeChildNode :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.ClientRect".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/ClientRect Mozilla ClientRect documentation>
+newtype ClientRect = ClientRect { unClientRect :: JSVal }
+
+instance Eq (ClientRect) where
+  (ClientRect a) == (ClientRect b) = js_eq a b
+
+instance PToJSVal ClientRect where
+  pToJSVal = unClientRect
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal ClientRect where
+  pFromJSVal = ClientRect
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal ClientRect where
+  toJSVal = return . unClientRect
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal ClientRect where
+  fromJSVal = return . fmap ClientRect . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject ClientRect where
+  typeGType _ = gTypeClientRect
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"ClientRect\"]" gTypeClientRect :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.ClientRectList".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/ClientRectList Mozilla ClientRectList documentation>
+newtype ClientRectList = ClientRectList { unClientRectList :: JSVal }
+
+instance Eq (ClientRectList) where
+  (ClientRectList a) == (ClientRectList b) = js_eq a b
+
+instance PToJSVal ClientRectList where
+  pToJSVal = unClientRectList
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal ClientRectList where
+  pFromJSVal = ClientRectList
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal ClientRectList where
+  toJSVal = return . unClientRectList
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal ClientRectList where
+  fromJSVal = return . fmap ClientRectList . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject ClientRectList where
+  typeGType _ = gTypeClientRectList
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"ClientRectList\"]" gTypeClientRectList :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.CloseEvent".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.Event"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/CloseEvent Mozilla CloseEvent documentation>
+newtype CloseEvent = CloseEvent { unCloseEvent :: JSVal }
+
+instance Eq (CloseEvent) where
+  (CloseEvent a) == (CloseEvent b) = js_eq a b
+
+instance PToJSVal CloseEvent where
+  pToJSVal = unCloseEvent
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal CloseEvent where
+  pFromJSVal = CloseEvent
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal CloseEvent where
+  toJSVal = return . unCloseEvent
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal CloseEvent where
+  fromJSVal = return . fmap CloseEvent . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsEvent CloseEvent
+instance IsGObject CloseEvent where
+  typeGType _ = gTypeCloseEvent
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"CloseEvent\"]" gTypeCloseEvent :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.CommandLineAPIHost".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/CommandLineAPIHost Mozilla CommandLineAPIHost documentation>
+newtype CommandLineAPIHost = CommandLineAPIHost { unCommandLineAPIHost :: JSVal }
+
+instance Eq (CommandLineAPIHost) where
+  (CommandLineAPIHost a) == (CommandLineAPIHost b) = js_eq a b
+
+instance PToJSVal CommandLineAPIHost where
+  pToJSVal = unCommandLineAPIHost
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal CommandLineAPIHost where
+  pFromJSVal = CommandLineAPIHost
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal CommandLineAPIHost where
+  toJSVal = return . unCommandLineAPIHost
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal CommandLineAPIHost where
+  fromJSVal = return . fmap CommandLineAPIHost . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject CommandLineAPIHost where
+  typeGType _ = gTypeCommandLineAPIHost
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"CommandLineAPIHost\"]" gTypeCommandLineAPIHost :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.Comment".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.CharacterData"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/Comment Mozilla Comment documentation>
+newtype Comment = Comment { unComment :: JSVal }
+
+instance Eq (Comment) where
+  (Comment a) == (Comment b) = js_eq a b
+
+instance PToJSVal Comment where
+  pToJSVal = unComment
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal Comment where
+  pFromJSVal = Comment
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal Comment where
+  toJSVal = return . unComment
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal Comment where
+  fromJSVal = return . fmap Comment . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsCharacterData Comment
+instance IsNode Comment
+instance IsEventTarget Comment
+instance IsGObject Comment where
+  typeGType _ = gTypeComment
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"Comment\"]" gTypeComment :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.CompositionEvent".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.UIEvent"
+--     * "GHCJS.DOM.Event"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/CompositionEvent Mozilla CompositionEvent documentation>
+newtype CompositionEvent = CompositionEvent { unCompositionEvent :: JSVal }
+
+instance Eq (CompositionEvent) where
+  (CompositionEvent a) == (CompositionEvent b) = js_eq a b
+
+instance PToJSVal CompositionEvent where
+  pToJSVal = unCompositionEvent
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal CompositionEvent where
+  pFromJSVal = CompositionEvent
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal CompositionEvent where
+  toJSVal = return . unCompositionEvent
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal CompositionEvent where
+  fromJSVal = return . fmap CompositionEvent . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsUIEvent CompositionEvent
+instance IsEvent CompositionEvent
+instance IsGObject CompositionEvent where
+  typeGType _ = gTypeCompositionEvent
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"CompositionEvent\"]" gTypeCompositionEvent :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.ConvolverNode".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.AudioNode"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/ConvolverNode Mozilla ConvolverNode documentation>
+newtype ConvolverNode = ConvolverNode { unConvolverNode :: JSVal }
+
+instance Eq (ConvolverNode) where
+  (ConvolverNode a) == (ConvolverNode b) = js_eq a b
+
+instance PToJSVal ConvolverNode where
+  pToJSVal = unConvolverNode
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal ConvolverNode where
+  pFromJSVal = ConvolverNode
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal ConvolverNode where
+  toJSVal = return . unConvolverNode
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal ConvolverNode where
+  fromJSVal = return . fmap ConvolverNode . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsAudioNode ConvolverNode
+instance IsEventTarget ConvolverNode
+instance IsGObject ConvolverNode where
+  typeGType _ = gTypeConvolverNode
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"ConvolverNode\"]" gTypeConvolverNode :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.Coordinates".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/Coordinates Mozilla Coordinates documentation>
+newtype Coordinates = Coordinates { unCoordinates :: JSVal }
+
+instance Eq (Coordinates) where
+  (Coordinates a) == (Coordinates b) = js_eq a b
+
+instance PToJSVal Coordinates where
+  pToJSVal = unCoordinates
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal Coordinates where
+  pFromJSVal = Coordinates
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal Coordinates where
+  toJSVal = return . unCoordinates
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal Coordinates where
+  fromJSVal = return . fmap Coordinates . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject Coordinates where
+  typeGType _ = gTypeCoordinates
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"Coordinates\"]" gTypeCoordinates :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.Counter".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/Counter Mozilla Counter documentation>
+newtype Counter = Counter { unCounter :: JSVal }
+
+instance Eq (Counter) where
+  (Counter a) == (Counter b) = js_eq a b
+
+instance PToJSVal Counter where
+  pToJSVal = unCounter
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal Counter where
+  pFromJSVal = Counter
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal Counter where
+  toJSVal = return . unCounter
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal Counter where
+  fromJSVal = return . fmap Counter . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject Counter where
+  typeGType _ = gTypeCounter
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"Counter\"]" gTypeCounter :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.Crypto".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/Crypto Mozilla Crypto documentation>
+newtype Crypto = Crypto { unCrypto :: JSVal }
+
+instance Eq (Crypto) where
+  (Crypto a) == (Crypto b) = js_eq a b
+
+instance PToJSVal Crypto where
+  pToJSVal = unCrypto
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal Crypto where
+  pFromJSVal = Crypto
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal Crypto where
+  toJSVal = return . unCrypto
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal Crypto where
+  fromJSVal = return . fmap Crypto . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject Crypto where
+  typeGType _ = gTypeCrypto
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"Crypto\"]" gTypeCrypto :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.CryptoKey".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/CryptoKey Mozilla CryptoKey documentation>
+newtype CryptoKey = CryptoKey { unCryptoKey :: JSVal }
+
+instance Eq (CryptoKey) where
+  (CryptoKey a) == (CryptoKey b) = js_eq a b
+
+instance PToJSVal CryptoKey where
+  pToJSVal = unCryptoKey
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal CryptoKey where
+  pFromJSVal = CryptoKey
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal CryptoKey where
+  toJSVal = return . unCryptoKey
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal CryptoKey where
+  fromJSVal = return . fmap CryptoKey . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject CryptoKey where
+  typeGType _ = gTypeCryptoKey
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"CryptoKey\"]" gTypeCryptoKey :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.CryptoKeyPair".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/CryptoKeyPair Mozilla CryptoKeyPair documentation>
+newtype CryptoKeyPair = CryptoKeyPair { unCryptoKeyPair :: JSVal }
+
+instance Eq (CryptoKeyPair) where
+  (CryptoKeyPair a) == (CryptoKeyPair b) = js_eq a b
+
+instance PToJSVal CryptoKeyPair where
+  pToJSVal = unCryptoKeyPair
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal CryptoKeyPair where
+  pFromJSVal = CryptoKeyPair
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal CryptoKeyPair where
+  toJSVal = return . unCryptoKeyPair
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal CryptoKeyPair where
+  fromJSVal = return . fmap CryptoKeyPair . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject CryptoKeyPair where
+  typeGType _ = gTypeCryptoKeyPair
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"CryptoKeyPair\"]" gTypeCryptoKeyPair :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.CustomEvent".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.Event"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/CustomEvent Mozilla CustomEvent documentation>
+newtype CustomEvent = CustomEvent { unCustomEvent :: JSVal }
+
+instance Eq (CustomEvent) where
+  (CustomEvent a) == (CustomEvent b) = js_eq a b
+
+instance PToJSVal CustomEvent where
+  pToJSVal = unCustomEvent
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal CustomEvent where
+  pFromJSVal = CustomEvent
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal CustomEvent where
+  toJSVal = return . unCustomEvent
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal CustomEvent where
+  fromJSVal = return . fmap CustomEvent . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsEvent CustomEvent
+instance IsGObject CustomEvent where
+  typeGType _ = gTypeCustomEvent
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"CustomEvent\"]" gTypeCustomEvent :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.DOMError".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/DOMError Mozilla DOMError documentation>
+newtype DOMError = DOMError { unDOMError :: JSVal }
+
+instance Eq (DOMError) where
+  (DOMError a) == (DOMError b) = js_eq a b
+
+instance PToJSVal DOMError where
+  pToJSVal = unDOMError
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal DOMError where
+  pFromJSVal = DOMError
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal DOMError where
+  toJSVal = return . unDOMError
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal DOMError where
+  fromJSVal = return . fmap DOMError . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+class IsGObject o => IsDOMError o
+toDOMError :: IsDOMError o => o -> DOMError
+toDOMError = DOMError . coerce
+
+instance IsDOMError DOMError
+instance IsGObject DOMError where
+  typeGType _ = gTypeDOMError
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"DOMError\"]" gTypeDOMError :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.DOMImplementation".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/DOMImplementation Mozilla DOMImplementation documentation>
+newtype DOMImplementation = DOMImplementation { unDOMImplementation :: JSVal }
+
+instance Eq (DOMImplementation) where
+  (DOMImplementation a) == (DOMImplementation b) = js_eq a b
+
+instance PToJSVal DOMImplementation where
+  pToJSVal = unDOMImplementation
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal DOMImplementation where
+  pFromJSVal = DOMImplementation
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal DOMImplementation where
+  toJSVal = return . unDOMImplementation
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal DOMImplementation where
+  fromJSVal = return . fmap DOMImplementation . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject DOMImplementation where
+  typeGType _ = gTypeDOMImplementation
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"DOMImplementation\"]" gTypeDOMImplementation :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.DOMNamedFlowCollection".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/WebKitNamedFlowCollection Mozilla WebKitNamedFlowCollection documentation>
+newtype DOMNamedFlowCollection = DOMNamedFlowCollection { unDOMNamedFlowCollection :: JSVal }
+
+instance Eq (DOMNamedFlowCollection) where
+  (DOMNamedFlowCollection a) == (DOMNamedFlowCollection b) = js_eq a b
+
+instance PToJSVal DOMNamedFlowCollection where
+  pToJSVal = unDOMNamedFlowCollection
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal DOMNamedFlowCollection where
+  pFromJSVal = DOMNamedFlowCollection
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal DOMNamedFlowCollection where
+  toJSVal = return . unDOMNamedFlowCollection
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal DOMNamedFlowCollection where
+  fromJSVal = return . fmap DOMNamedFlowCollection . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject DOMNamedFlowCollection where
+  typeGType _ = gTypeDOMNamedFlowCollection
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"WebKitNamedFlowCollection\"]" gTypeDOMNamedFlowCollection :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.DOMParser".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/DOMParser Mozilla DOMParser documentation>
+newtype DOMParser = DOMParser { unDOMParser :: JSVal }
+
+instance Eq (DOMParser) where
+  (DOMParser a) == (DOMParser b) = js_eq a b
+
+instance PToJSVal DOMParser where
+  pToJSVal = unDOMParser
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal DOMParser where
+  pFromJSVal = DOMParser
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal DOMParser where
+  toJSVal = return . unDOMParser
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal DOMParser where
+  fromJSVal = return . fmap DOMParser . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject DOMParser where
+  typeGType _ = gTypeDOMParser
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"DOMParser\"]" gTypeDOMParser :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.DOMSettableTokenList".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.DOMTokenList"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/DOMSettableTokenList Mozilla DOMSettableTokenList documentation>
+newtype DOMSettableTokenList = DOMSettableTokenList { unDOMSettableTokenList :: JSVal }
+
+instance Eq (DOMSettableTokenList) where
+  (DOMSettableTokenList a) == (DOMSettableTokenList b) = js_eq a b
+
+instance PToJSVal DOMSettableTokenList where
+  pToJSVal = unDOMSettableTokenList
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal DOMSettableTokenList where
+  pFromJSVal = DOMSettableTokenList
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal DOMSettableTokenList where
+  toJSVal = return . unDOMSettableTokenList
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal DOMSettableTokenList where
+  fromJSVal = return . fmap DOMSettableTokenList . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsDOMTokenList DOMSettableTokenList
+instance IsGObject DOMSettableTokenList where
+  typeGType _ = gTypeDOMSettableTokenList
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"DOMSettableTokenList\"]" gTypeDOMSettableTokenList :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.DOMStringList".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/DOMStringList Mozilla DOMStringList documentation>
+newtype DOMStringList = DOMStringList { unDOMStringList :: JSVal }
+
+instance Eq (DOMStringList) where
+  (DOMStringList a) == (DOMStringList b) = js_eq a b
+
+instance PToJSVal DOMStringList where
+  pToJSVal = unDOMStringList
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal DOMStringList where
+  pFromJSVal = DOMStringList
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal DOMStringList where
+  toJSVal = return . unDOMStringList
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal DOMStringList where
+  fromJSVal = return . fmap DOMStringList . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject DOMStringList where
+  typeGType _ = gTypeDOMStringList
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"DOMStringList\"]" gTypeDOMStringList :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.DOMStringMap".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/DOMStringMap Mozilla DOMStringMap documentation>
+newtype DOMStringMap = DOMStringMap { unDOMStringMap :: JSVal }
+
+instance Eq (DOMStringMap) where
+  (DOMStringMap a) == (DOMStringMap b) = js_eq a b
+
+instance PToJSVal DOMStringMap where
+  pToJSVal = unDOMStringMap
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal DOMStringMap where
+  pFromJSVal = DOMStringMap
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal DOMStringMap where
+  toJSVal = return . unDOMStringMap
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal DOMStringMap where
+  fromJSVal = return . fmap DOMStringMap . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject DOMStringMap where
+  typeGType _ = gTypeDOMStringMap
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"DOMStringMap\"]" gTypeDOMStringMap :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.DOMTokenList".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/DOMTokenList Mozilla DOMTokenList documentation>
+newtype DOMTokenList = DOMTokenList { unDOMTokenList :: JSVal }
+
+instance Eq (DOMTokenList) where
+  (DOMTokenList a) == (DOMTokenList b) = js_eq a b
+
+instance PToJSVal DOMTokenList where
+  pToJSVal = unDOMTokenList
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal DOMTokenList where
+  pFromJSVal = DOMTokenList
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal DOMTokenList where
+  toJSVal = return . unDOMTokenList
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal DOMTokenList where
+  fromJSVal = return . fmap DOMTokenList . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+class IsGObject o => IsDOMTokenList o
+toDOMTokenList :: IsDOMTokenList o => o -> DOMTokenList
+toDOMTokenList = DOMTokenList . coerce
+
+instance IsDOMTokenList DOMTokenList
+instance IsGObject DOMTokenList where
+  typeGType _ = gTypeDOMTokenList
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"DOMTokenList\"]" gTypeDOMTokenList :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.DataCue".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.TextTrackCue"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/WebKitDataCue Mozilla WebKitDataCue documentation>
+newtype DataCue = DataCue { unDataCue :: JSVal }
+
+instance Eq (DataCue) where
+  (DataCue a) == (DataCue b) = js_eq a b
+
+instance PToJSVal DataCue where
+  pToJSVal = unDataCue
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal DataCue where
+  pFromJSVal = DataCue
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal DataCue where
+  toJSVal = return . unDataCue
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal DataCue where
+  fromJSVal = return . fmap DataCue . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsTextTrackCue DataCue
+instance IsEventTarget DataCue
+instance IsGObject DataCue where
+  typeGType _ = gTypeDataCue
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"WebKitDataCue\"]" gTypeDataCue :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.DataTransfer".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/DataTransfer Mozilla DataTransfer documentation>
+newtype DataTransfer = DataTransfer { unDataTransfer :: JSVal }
+
+instance Eq (DataTransfer) where
+  (DataTransfer a) == (DataTransfer b) = js_eq a b
+
+instance PToJSVal DataTransfer where
+  pToJSVal = unDataTransfer
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal DataTransfer where
+  pFromJSVal = DataTransfer
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal DataTransfer where
+  toJSVal = return . unDataTransfer
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal DataTransfer where
+  fromJSVal = return . fmap DataTransfer . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject DataTransfer where
+  typeGType _ = gTypeDataTransfer
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"DataTransfer\"]" gTypeDataTransfer :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.DataTransferItem".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/DataTransferItem Mozilla DataTransferItem documentation>
+newtype DataTransferItem = DataTransferItem { unDataTransferItem :: JSVal }
+
+instance Eq (DataTransferItem) where
+  (DataTransferItem a) == (DataTransferItem b) = js_eq a b
+
+instance PToJSVal DataTransferItem where
+  pToJSVal = unDataTransferItem
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal DataTransferItem where
+  pFromJSVal = DataTransferItem
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal DataTransferItem where
+  toJSVal = return . unDataTransferItem
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal DataTransferItem where
+  fromJSVal = return . fmap DataTransferItem . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject DataTransferItem where
+  typeGType _ = gTypeDataTransferItem
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"DataTransferItem\"]" gTypeDataTransferItem :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.DataTransferItemList".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/DataTransferItemList Mozilla DataTransferItemList documentation>
+newtype DataTransferItemList = DataTransferItemList { unDataTransferItemList :: JSVal }
+
+instance Eq (DataTransferItemList) where
+  (DataTransferItemList a) == (DataTransferItemList b) = js_eq a b
+
+instance PToJSVal DataTransferItemList where
+  pToJSVal = unDataTransferItemList
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal DataTransferItemList where
+  pFromJSVal = DataTransferItemList
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal DataTransferItemList where
+  toJSVal = return . unDataTransferItemList
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal DataTransferItemList where
+  fromJSVal = return . fmap DataTransferItemList . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject DataTransferItemList where
+  typeGType _ = gTypeDataTransferItemList
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"DataTransferItemList\"]" gTypeDataTransferItemList :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.Database".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/Database Mozilla Database documentation>
+newtype Database = Database { unDatabase :: JSVal }
+
+instance Eq (Database) where
+  (Database a) == (Database b) = js_eq a b
+
+instance PToJSVal Database where
+  pToJSVal = unDatabase
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal Database where
+  pFromJSVal = Database
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal Database where
+  toJSVal = return . unDatabase
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal Database where
+  fromJSVal = return . fmap Database . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject Database where
+  typeGType _ = gTypeDatabase
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"Database\"]" gTypeDatabase :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.DedicatedWorkerGlobalScope".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.WorkerGlobalScope"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/DedicatedWorkerGlobalScope Mozilla DedicatedWorkerGlobalScope documentation>
+newtype DedicatedWorkerGlobalScope = DedicatedWorkerGlobalScope { unDedicatedWorkerGlobalScope :: JSVal }
+
+instance Eq (DedicatedWorkerGlobalScope) where
+  (DedicatedWorkerGlobalScope a) == (DedicatedWorkerGlobalScope b) = js_eq a b
+
+instance PToJSVal DedicatedWorkerGlobalScope where
+  pToJSVal = unDedicatedWorkerGlobalScope
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal DedicatedWorkerGlobalScope where
+  pFromJSVal = DedicatedWorkerGlobalScope
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal DedicatedWorkerGlobalScope where
+  toJSVal = return . unDedicatedWorkerGlobalScope
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal DedicatedWorkerGlobalScope where
+  fromJSVal = return . fmap DedicatedWorkerGlobalScope . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsWorkerGlobalScope DedicatedWorkerGlobalScope
+instance IsEventTarget DedicatedWorkerGlobalScope
+instance IsGObject DedicatedWorkerGlobalScope where
+  typeGType _ = gTypeDedicatedWorkerGlobalScope
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"DedicatedWorkerGlobalScope\"]" gTypeDedicatedWorkerGlobalScope :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.DelayNode".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.AudioNode"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/DelayNode Mozilla DelayNode documentation>
+newtype DelayNode = DelayNode { unDelayNode :: JSVal }
+
+instance Eq (DelayNode) where
+  (DelayNode a) == (DelayNode b) = js_eq a b
+
+instance PToJSVal DelayNode where
+  pToJSVal = unDelayNode
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal DelayNode where
+  pFromJSVal = DelayNode
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal DelayNode where
+  toJSVal = return . unDelayNode
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal DelayNode where
+  fromJSVal = return . fmap DelayNode . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsAudioNode DelayNode
+instance IsEventTarget DelayNode
+instance IsGObject DelayNode where
+  typeGType _ = gTypeDelayNode
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"DelayNode\"]" gTypeDelayNode :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.DeviceMotionEvent".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.Event"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/DeviceMotionEvent Mozilla DeviceMotionEvent documentation>
+newtype DeviceMotionEvent = DeviceMotionEvent { unDeviceMotionEvent :: JSVal }
+
+instance Eq (DeviceMotionEvent) where
+  (DeviceMotionEvent a) == (DeviceMotionEvent b) = js_eq a b
+
+instance PToJSVal DeviceMotionEvent where
+  pToJSVal = unDeviceMotionEvent
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal DeviceMotionEvent where
+  pFromJSVal = DeviceMotionEvent
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal DeviceMotionEvent where
+  toJSVal = return . unDeviceMotionEvent
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal DeviceMotionEvent where
+  fromJSVal = return . fmap DeviceMotionEvent . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsEvent DeviceMotionEvent
+instance IsGObject DeviceMotionEvent where
+  typeGType _ = gTypeDeviceMotionEvent
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"DeviceMotionEvent\"]" gTypeDeviceMotionEvent :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.DeviceOrientationEvent".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.Event"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/DeviceOrientationEvent Mozilla DeviceOrientationEvent documentation>
+newtype DeviceOrientationEvent = DeviceOrientationEvent { unDeviceOrientationEvent :: JSVal }
+
+instance Eq (DeviceOrientationEvent) where
+  (DeviceOrientationEvent a) == (DeviceOrientationEvent b) = js_eq a b
+
+instance PToJSVal DeviceOrientationEvent where
+  pToJSVal = unDeviceOrientationEvent
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal DeviceOrientationEvent where
+  pFromJSVal = DeviceOrientationEvent
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal DeviceOrientationEvent where
+  toJSVal = return . unDeviceOrientationEvent
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal DeviceOrientationEvent where
+  fromJSVal = return . fmap DeviceOrientationEvent . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsEvent DeviceOrientationEvent
+instance IsGObject DeviceOrientationEvent where
+  typeGType _ = gTypeDeviceOrientationEvent
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"DeviceOrientationEvent\"]" gTypeDeviceOrientationEvent :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.DeviceProximityEvent".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.Event"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/DeviceProximityEvent Mozilla DeviceProximityEvent documentation>
+newtype DeviceProximityEvent = DeviceProximityEvent { unDeviceProximityEvent :: JSVal }
+
+instance Eq (DeviceProximityEvent) where
+  (DeviceProximityEvent a) == (DeviceProximityEvent b) = js_eq a b
+
+instance PToJSVal DeviceProximityEvent where
+  pToJSVal = unDeviceProximityEvent
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal DeviceProximityEvent where
+  pFromJSVal = DeviceProximityEvent
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal DeviceProximityEvent where
+  toJSVal = return . unDeviceProximityEvent
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal DeviceProximityEvent where
+  fromJSVal = return . fmap DeviceProximityEvent . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsEvent DeviceProximityEvent
+instance IsGObject DeviceProximityEvent where
+  typeGType _ = gTypeDeviceProximityEvent
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"DeviceProximityEvent\"]" gTypeDeviceProximityEvent :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.Document".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/Document Mozilla Document documentation>
+newtype Document = Document { unDocument :: JSVal }
+
+instance Eq (Document) where
+  (Document a) == (Document b) = js_eq a b
+
+instance PToJSVal Document where
+  pToJSVal = unDocument
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal Document where
+  pFromJSVal = Document
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal Document where
+  toJSVal = return . unDocument
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal Document where
+  fromJSVal = return . fmap Document . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+class IsNode o => IsDocument o
+toDocument :: IsDocument o => o -> Document
+toDocument = Document . coerce
+
+instance IsDocument Document
+instance IsNode Document
+instance IsEventTarget Document
+instance IsGObject Document where
+  typeGType _ = gTypeDocument
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"Document\"]" gTypeDocument :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.DocumentFragment".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/DocumentFragment Mozilla DocumentFragment documentation>
+newtype DocumentFragment = DocumentFragment { unDocumentFragment :: JSVal }
+
+instance Eq (DocumentFragment) where
+  (DocumentFragment a) == (DocumentFragment b) = js_eq a b
+
+instance PToJSVal DocumentFragment where
+  pToJSVal = unDocumentFragment
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal DocumentFragment where
+  pFromJSVal = DocumentFragment
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal DocumentFragment where
+  toJSVal = return . unDocumentFragment
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal DocumentFragment where
+  fromJSVal = return . fmap DocumentFragment . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsNode DocumentFragment
+instance IsEventTarget DocumentFragment
+instance IsGObject DocumentFragment where
+  typeGType _ = gTypeDocumentFragment
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"DocumentFragment\"]" gTypeDocumentFragment :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.DocumentType".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/DocumentType Mozilla DocumentType documentation>
+newtype DocumentType = DocumentType { unDocumentType :: JSVal }
+
+instance Eq (DocumentType) where
+  (DocumentType a) == (DocumentType b) = js_eq a b
+
+instance PToJSVal DocumentType where
+  pToJSVal = unDocumentType
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal DocumentType where
+  pFromJSVal = DocumentType
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal DocumentType where
+  toJSVal = return . unDocumentType
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal DocumentType where
+  fromJSVal = return . fmap DocumentType . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsNode DocumentType
+instance IsEventTarget DocumentType
+instance IsGObject DocumentType where
+  typeGType _ = gTypeDocumentType
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"DocumentType\"]" gTypeDocumentType :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.DynamicsCompressorNode".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.AudioNode"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/DynamicsCompressorNode Mozilla DynamicsCompressorNode documentation>
+newtype DynamicsCompressorNode = DynamicsCompressorNode { unDynamicsCompressorNode :: JSVal }
+
+instance Eq (DynamicsCompressorNode) where
+  (DynamicsCompressorNode a) == (DynamicsCompressorNode b) = js_eq a b
+
+instance PToJSVal DynamicsCompressorNode where
+  pToJSVal = unDynamicsCompressorNode
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal DynamicsCompressorNode where
+  pFromJSVal = DynamicsCompressorNode
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal DynamicsCompressorNode where
+  toJSVal = return . unDynamicsCompressorNode
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal DynamicsCompressorNode where
+  fromJSVal = return . fmap DynamicsCompressorNode . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsAudioNode DynamicsCompressorNode
+instance IsEventTarget DynamicsCompressorNode
+instance IsGObject DynamicsCompressorNode where
+  typeGType _ = gTypeDynamicsCompressorNode
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"DynamicsCompressorNode\"]" gTypeDynamicsCompressorNode :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.EXTBlendMinMax".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/EXTBlendMinMax Mozilla EXTBlendMinMax documentation>
+newtype EXTBlendMinMax = EXTBlendMinMax { unEXTBlendMinMax :: JSVal }
+
+instance Eq (EXTBlendMinMax) where
+  (EXTBlendMinMax a) == (EXTBlendMinMax b) = js_eq a b
+
+instance PToJSVal EXTBlendMinMax where
+  pToJSVal = unEXTBlendMinMax
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal EXTBlendMinMax where
+  pFromJSVal = EXTBlendMinMax
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal EXTBlendMinMax where
+  toJSVal = return . unEXTBlendMinMax
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal EXTBlendMinMax where
+  fromJSVal = return . fmap EXTBlendMinMax . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject EXTBlendMinMax where
+  typeGType _ = gTypeEXTBlendMinMax
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"EXTBlendMinMax\"]" gTypeEXTBlendMinMax :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.EXTFragDepth".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/EXTFragDepth Mozilla EXTFragDepth documentation>
+newtype EXTFragDepth = EXTFragDepth { unEXTFragDepth :: JSVal }
+
+instance Eq (EXTFragDepth) where
+  (EXTFragDepth a) == (EXTFragDepth b) = js_eq a b
+
+instance PToJSVal EXTFragDepth where
+  pToJSVal = unEXTFragDepth
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal EXTFragDepth where
+  pFromJSVal = EXTFragDepth
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal EXTFragDepth where
+  toJSVal = return . unEXTFragDepth
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal EXTFragDepth where
+  fromJSVal = return . fmap EXTFragDepth . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject EXTFragDepth where
+  typeGType _ = gTypeEXTFragDepth
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"EXTFragDepth\"]" gTypeEXTFragDepth :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.EXTShaderTextureLOD".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/EXTShaderTextureLOD Mozilla EXTShaderTextureLOD documentation>
+newtype EXTShaderTextureLOD = EXTShaderTextureLOD { unEXTShaderTextureLOD :: JSVal }
+
+instance Eq (EXTShaderTextureLOD) where
+  (EXTShaderTextureLOD a) == (EXTShaderTextureLOD b) = js_eq a b
+
+instance PToJSVal EXTShaderTextureLOD where
+  pToJSVal = unEXTShaderTextureLOD
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal EXTShaderTextureLOD where
+  pFromJSVal = EXTShaderTextureLOD
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal EXTShaderTextureLOD where
+  toJSVal = return . unEXTShaderTextureLOD
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal EXTShaderTextureLOD where
+  fromJSVal = return . fmap EXTShaderTextureLOD . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject EXTShaderTextureLOD where
+  typeGType _ = gTypeEXTShaderTextureLOD
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"EXTShaderTextureLOD\"]" gTypeEXTShaderTextureLOD :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.EXTTextureFilterAnisotropic".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/EXTTextureFilterAnisotropic Mozilla EXTTextureFilterAnisotropic documentation>
+newtype EXTTextureFilterAnisotropic = EXTTextureFilterAnisotropic { unEXTTextureFilterAnisotropic :: JSVal }
+
+instance Eq (EXTTextureFilterAnisotropic) where
+  (EXTTextureFilterAnisotropic a) == (EXTTextureFilterAnisotropic b) = js_eq a b
+
+instance PToJSVal EXTTextureFilterAnisotropic where
+  pToJSVal = unEXTTextureFilterAnisotropic
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal EXTTextureFilterAnisotropic where
+  pFromJSVal = EXTTextureFilterAnisotropic
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal EXTTextureFilterAnisotropic where
+  toJSVal = return . unEXTTextureFilterAnisotropic
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal EXTTextureFilterAnisotropic where
+  fromJSVal = return . fmap EXTTextureFilterAnisotropic . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject EXTTextureFilterAnisotropic where
+  typeGType _ = gTypeEXTTextureFilterAnisotropic
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"EXTTextureFilterAnisotropic\"]" gTypeEXTTextureFilterAnisotropic :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.EXTsRGB".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/EXTsRGB Mozilla EXTsRGB documentation>
+newtype EXTsRGB = EXTsRGB { unEXTsRGB :: JSVal }
+
+instance Eq (EXTsRGB) where
+  (EXTsRGB a) == (EXTsRGB b) = js_eq a b
+
+instance PToJSVal EXTsRGB where
+  pToJSVal = unEXTsRGB
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal EXTsRGB where
+  pFromJSVal = EXTsRGB
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal EXTsRGB where
+  toJSVal = return . unEXTsRGB
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal EXTsRGB where
+  fromJSVal = return . fmap EXTsRGB . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject EXTsRGB where
+  typeGType _ = gTypeEXTsRGB
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"EXTsRGB\"]" gTypeEXTsRGB :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.Element".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/Element Mozilla Element documentation>
+newtype Element = Element { unElement :: JSVal }
+
+instance Eq (Element) where
+  (Element a) == (Element b) = js_eq a b
+
+instance PToJSVal Element where
+  pToJSVal = unElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal Element where
+  pFromJSVal = Element
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal Element where
+  toJSVal = return . unElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal Element where
+  fromJSVal = return . fmap Element . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+class IsNode o => IsElement o
+toElement :: IsElement o => o -> Element
+toElement = Element . coerce
+
+instance IsElement Element
+instance IsNode Element
+instance IsEventTarget Element
+instance IsGObject Element where
+  typeGType _ = gTypeElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"Element\"]" gTypeElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.Entity".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/Entity Mozilla Entity documentation>
+newtype Entity = Entity { unEntity :: JSVal }
+
+instance Eq (Entity) where
+  (Entity a) == (Entity b) = js_eq a b
+
+instance PToJSVal Entity where
+  pToJSVal = unEntity
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal Entity where
+  pFromJSVal = Entity
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal Entity where
+  toJSVal = return . unEntity
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal Entity where
+  fromJSVal = return . fmap Entity . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsNode Entity
+instance IsEventTarget Entity
+instance IsGObject Entity where
+  typeGType _ = gTypeEntity
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"Entity\"]" gTypeEntity :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.EntityReference".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/EntityReference Mozilla EntityReference documentation>
+newtype EntityReference = EntityReference { unEntityReference :: JSVal }
+
+instance Eq (EntityReference) where
+  (EntityReference a) == (EntityReference b) = js_eq a b
+
+instance PToJSVal EntityReference where
+  pToJSVal = unEntityReference
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal EntityReference where
+  pFromJSVal = EntityReference
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal EntityReference where
+  toJSVal = return . unEntityReference
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal EntityReference where
+  fromJSVal = return . fmap EntityReference . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsNode EntityReference
+instance IsEventTarget EntityReference
+instance IsGObject EntityReference where
+  typeGType _ = gTypeEntityReference
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"EntityReference\"]" gTypeEntityReference :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.ErrorEvent".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.Event"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/ErrorEvent Mozilla ErrorEvent documentation>
+newtype ErrorEvent = ErrorEvent { unErrorEvent :: JSVal }
+
+instance Eq (ErrorEvent) where
+  (ErrorEvent a) == (ErrorEvent b) = js_eq a b
+
+instance PToJSVal ErrorEvent where
+  pToJSVal = unErrorEvent
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal ErrorEvent where
+  pFromJSVal = ErrorEvent
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal ErrorEvent where
+  toJSVal = return . unErrorEvent
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal ErrorEvent where
+  fromJSVal = return . fmap ErrorEvent . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsEvent ErrorEvent
+instance IsGObject ErrorEvent where
+  typeGType _ = gTypeErrorEvent
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"ErrorEvent\"]" gTypeErrorEvent :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.Event".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/Event Mozilla Event documentation>
+newtype Event = Event { unEvent :: JSVal }
+
+instance Eq (Event) where
+  (Event a) == (Event b) = js_eq a b
+
+instance PToJSVal Event where
+  pToJSVal = unEvent
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal Event where
+  pFromJSVal = Event
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal Event where
+  toJSVal = return . unEvent
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal Event where
+  fromJSVal = return . fmap Event . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+class IsGObject o => IsEvent o
+toEvent :: IsEvent o => o -> Event
+toEvent = Event . coerce
+
+instance IsEvent Event
+instance IsGObject Event where
+  typeGType _ = gTypeEvent
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"Event\"]" gTypeEvent :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.EventListener".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/EventListener Mozilla EventListener documentation>
+newtype EventListener = EventListener { unEventListener :: JSVal }
+
+instance Eq (EventListener) where
+  (EventListener a) == (EventListener b) = js_eq a b
+
+instance PToJSVal EventListener where
+  pToJSVal = unEventListener
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal EventListener where
+  pFromJSVal = EventListener
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal EventListener where
+  toJSVal = return . unEventListener
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal EventListener where
+  fromJSVal = return . fmap EventListener . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject EventListener where
+  typeGType _ = gTypeEventListener
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"EventListener\"]" gTypeEventListener :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.EventSource".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/EventSource Mozilla EventSource documentation>
+newtype EventSource = EventSource { unEventSource :: JSVal }
+
+instance Eq (EventSource) where
+  (EventSource a) == (EventSource b) = js_eq a b
+
+instance PToJSVal EventSource where
+  pToJSVal = unEventSource
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal EventSource where
+  pFromJSVal = EventSource
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal EventSource where
+  toJSVal = return . unEventSource
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal EventSource where
+  fromJSVal = return . fmap EventSource . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsEventTarget EventSource
+instance IsGObject EventSource where
+  typeGType _ = gTypeEventSource
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"EventSource\"]" gTypeEventSource :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.EventTarget".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/EventTarget Mozilla EventTarget documentation>
+newtype EventTarget = EventTarget { unEventTarget :: JSVal }
+
+instance Eq (EventTarget) where
+  (EventTarget a) == (EventTarget b) = js_eq a b
+
+instance PToJSVal EventTarget where
+  pToJSVal = unEventTarget
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal EventTarget where
+  pFromJSVal = EventTarget
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal EventTarget where
+  toJSVal = return . unEventTarget
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal EventTarget where
+  fromJSVal = return . fmap EventTarget . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+class IsGObject o => IsEventTarget o
+toEventTarget :: IsEventTarget o => o -> EventTarget
+toEventTarget = EventTarget . coerce
+
+instance IsEventTarget EventTarget
+instance IsGObject EventTarget where
+  typeGType _ = gTypeEventTarget
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"EventTarget\"]" gTypeEventTarget :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.File".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.Blob"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/File Mozilla File documentation>
+newtype File = File { unFile :: JSVal }
+
+instance Eq (File) where
+  (File a) == (File b) = js_eq a b
+
+instance PToJSVal File where
+  pToJSVal = unFile
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal File where
+  pFromJSVal = File
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal File where
+  toJSVal = return . unFile
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal File where
+  fromJSVal = return . fmap File . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsBlob File
+instance IsGObject File where
+  typeGType _ = gTypeFile
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"File\"]" gTypeFile :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.FileError".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/FileError Mozilla FileError documentation>
+newtype FileError = FileError { unFileError :: JSVal }
+
+instance Eq (FileError) where
+  (FileError a) == (FileError b) = js_eq a b
+
+instance PToJSVal FileError where
+  pToJSVal = unFileError
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal FileError where
+  pFromJSVal = FileError
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal FileError where
+  toJSVal = return . unFileError
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal FileError where
+  fromJSVal = return . fmap FileError . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject FileError where
+  typeGType _ = gTypeFileError
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"FileError\"]" gTypeFileError :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.FileList".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/FileList Mozilla FileList documentation>
+newtype FileList = FileList { unFileList :: JSVal }
+
+instance Eq (FileList) where
+  (FileList a) == (FileList b) = js_eq a b
+
+instance PToJSVal FileList where
+  pToJSVal = unFileList
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal FileList where
+  pFromJSVal = FileList
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal FileList where
+  toJSVal = return . unFileList
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal FileList where
+  fromJSVal = return . fmap FileList . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject FileList where
+  typeGType _ = gTypeFileList
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"FileList\"]" gTypeFileList :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.FileReader".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/FileReader Mozilla FileReader documentation>
+newtype FileReader = FileReader { unFileReader :: JSVal }
+
+instance Eq (FileReader) where
+  (FileReader a) == (FileReader b) = js_eq a b
+
+instance PToJSVal FileReader where
+  pToJSVal = unFileReader
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal FileReader where
+  pFromJSVal = FileReader
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal FileReader where
+  toJSVal = return . unFileReader
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal FileReader where
+  fromJSVal = return . fmap FileReader . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsEventTarget FileReader
+instance IsGObject FileReader where
+  typeGType _ = gTypeFileReader
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"FileReader\"]" gTypeFileReader :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.FileReaderSync".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/FileReaderSync Mozilla FileReaderSync documentation>
+newtype FileReaderSync = FileReaderSync { unFileReaderSync :: JSVal }
+
+instance Eq (FileReaderSync) where
+  (FileReaderSync a) == (FileReaderSync b) = js_eq a b
+
+instance PToJSVal FileReaderSync where
+  pToJSVal = unFileReaderSync
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal FileReaderSync where
+  pFromJSVal = FileReaderSync
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal FileReaderSync where
+  toJSVal = return . unFileReaderSync
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal FileReaderSync where
+  fromJSVal = return . fmap FileReaderSync . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject FileReaderSync where
+  typeGType _ = gTypeFileReaderSync
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"FileReaderSync\"]" gTypeFileReaderSync :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.FocusEvent".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.UIEvent"
+--     * "GHCJS.DOM.Event"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/FocusEvent Mozilla FocusEvent documentation>
+newtype FocusEvent = FocusEvent { unFocusEvent :: JSVal }
+
+instance Eq (FocusEvent) where
+  (FocusEvent a) == (FocusEvent b) = js_eq a b
+
+instance PToJSVal FocusEvent where
+  pToJSVal = unFocusEvent
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal FocusEvent where
+  pFromJSVal = FocusEvent
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal FocusEvent where
+  toJSVal = return . unFocusEvent
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal FocusEvent where
+  fromJSVal = return . fmap FocusEvent . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsUIEvent FocusEvent
+instance IsEvent FocusEvent
+instance IsGObject FocusEvent where
+  typeGType _ = gTypeFocusEvent
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"FocusEvent\"]" gTypeFocusEvent :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.FontLoader".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/FontLoader Mozilla FontLoader documentation>
+newtype FontLoader = FontLoader { unFontLoader :: JSVal }
+
+instance Eq (FontLoader) where
+  (FontLoader a) == (FontLoader b) = js_eq a b
+
+instance PToJSVal FontLoader where
+  pToJSVal = unFontLoader
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal FontLoader where
+  pFromJSVal = FontLoader
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal FontLoader where
+  toJSVal = return . unFontLoader
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal FontLoader where
+  fromJSVal = return . fmap FontLoader . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsEventTarget FontLoader
+instance IsGObject FontLoader where
+  typeGType _ = gTypeFontLoader
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"FontLoader\"]" gTypeFontLoader :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.FormData".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/FormData Mozilla FormData documentation>
+newtype FormData = FormData { unFormData :: JSVal }
+
+instance Eq (FormData) where
+  (FormData a) == (FormData b) = js_eq a b
+
+instance PToJSVal FormData where
+  pToJSVal = unFormData
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal FormData where
+  pFromJSVal = FormData
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal FormData where
+  toJSVal = return . unFormData
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal FormData where
+  fromJSVal = return . fmap FormData . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject FormData where
+  typeGType _ = gTypeFormData
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"FormData\"]" gTypeFormData :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.GainNode".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.AudioNode"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/GainNode Mozilla GainNode documentation>
+newtype GainNode = GainNode { unGainNode :: JSVal }
+
+instance Eq (GainNode) where
+  (GainNode a) == (GainNode b) = js_eq a b
+
+instance PToJSVal GainNode where
+  pToJSVal = unGainNode
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal GainNode where
+  pFromJSVal = GainNode
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal GainNode where
+  toJSVal = return . unGainNode
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal GainNode where
+  fromJSVal = return . fmap GainNode . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsAudioNode GainNode
+instance IsEventTarget GainNode
+instance IsGObject GainNode where
+  typeGType _ = gTypeGainNode
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"GainNode\"]" gTypeGainNode :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.Gamepad".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/Gamepad Mozilla Gamepad documentation>
+newtype Gamepad = Gamepad { unGamepad :: JSVal }
+
+instance Eq (Gamepad) where
+  (Gamepad a) == (Gamepad b) = js_eq a b
+
+instance PToJSVal Gamepad where
+  pToJSVal = unGamepad
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal Gamepad where
+  pFromJSVal = Gamepad
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal Gamepad where
+  toJSVal = return . unGamepad
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal Gamepad where
+  fromJSVal = return . fmap Gamepad . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject Gamepad where
+  typeGType _ = gTypeGamepad
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"Gamepad\"]" gTypeGamepad :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.GamepadButton".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/GamepadButton Mozilla GamepadButton documentation>
+newtype GamepadButton = GamepadButton { unGamepadButton :: JSVal }
+
+instance Eq (GamepadButton) where
+  (GamepadButton a) == (GamepadButton b) = js_eq a b
+
+instance PToJSVal GamepadButton where
+  pToJSVal = unGamepadButton
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal GamepadButton where
+  pFromJSVal = GamepadButton
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal GamepadButton where
+  toJSVal = return . unGamepadButton
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal GamepadButton where
+  fromJSVal = return . fmap GamepadButton . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject GamepadButton where
+  typeGType _ = gTypeGamepadButton
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"GamepadButton\"]" gTypeGamepadButton :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.GamepadEvent".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.Event"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/GamepadEvent Mozilla GamepadEvent documentation>
+newtype GamepadEvent = GamepadEvent { unGamepadEvent :: JSVal }
+
+instance Eq (GamepadEvent) where
+  (GamepadEvent a) == (GamepadEvent b) = js_eq a b
+
+instance PToJSVal GamepadEvent where
+  pToJSVal = unGamepadEvent
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal GamepadEvent where
+  pFromJSVal = GamepadEvent
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal GamepadEvent where
+  toJSVal = return . unGamepadEvent
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal GamepadEvent where
+  fromJSVal = return . fmap GamepadEvent . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsEvent GamepadEvent
+instance IsGObject GamepadEvent where
+  typeGType _ = gTypeGamepadEvent
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"GamepadEvent\"]" gTypeGamepadEvent :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.Geolocation".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/Geolocation Mozilla Geolocation documentation>
+newtype Geolocation = Geolocation { unGeolocation :: JSVal }
+
+instance Eq (Geolocation) where
+  (Geolocation a) == (Geolocation b) = js_eq a b
+
+instance PToJSVal Geolocation where
+  pToJSVal = unGeolocation
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal Geolocation where
+  pFromJSVal = Geolocation
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal Geolocation where
+  toJSVal = return . unGeolocation
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal Geolocation where
+  fromJSVal = return . fmap Geolocation . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject Geolocation where
+  typeGType _ = gTypeGeolocation
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"Geolocation\"]" gTypeGeolocation :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.Geoposition".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/Geoposition Mozilla Geoposition documentation>
+newtype Geoposition = Geoposition { unGeoposition :: JSVal }
+
+instance Eq (Geoposition) where
+  (Geoposition a) == (Geoposition b) = js_eq a b
+
+instance PToJSVal Geoposition where
+  pToJSVal = unGeoposition
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal Geoposition where
+  pFromJSVal = Geoposition
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal Geoposition where
+  toJSVal = return . unGeoposition
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal Geoposition where
+  fromJSVal = return . fmap Geoposition . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject Geoposition where
+  typeGType _ = gTypeGeoposition
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"Geoposition\"]" gTypeGeoposition :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.HTMLAllCollection".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/HTMLAllCollection Mozilla HTMLAllCollection documentation>
+newtype HTMLAllCollection = HTMLAllCollection { unHTMLAllCollection :: JSVal }
+
+instance Eq (HTMLAllCollection) where
+  (HTMLAllCollection a) == (HTMLAllCollection b) = js_eq a b
+
+instance PToJSVal HTMLAllCollection where
+  pToJSVal = unHTMLAllCollection
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal HTMLAllCollection where
+  pFromJSVal = HTMLAllCollection
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal HTMLAllCollection where
+  toJSVal = return . unHTMLAllCollection
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal HTMLAllCollection where
+  fromJSVal = return . fmap HTMLAllCollection . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject HTMLAllCollection where
+  typeGType _ = gTypeHTMLAllCollection
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"HTMLAllCollection\"]" gTypeHTMLAllCollection :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.HTMLAnchorElement".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.HTMLElement"
+--     * "GHCJS.DOM.Element"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/HTMLAnchorElement Mozilla HTMLAnchorElement documentation>
+newtype HTMLAnchorElement = HTMLAnchorElement { unHTMLAnchorElement :: JSVal }
+
+instance Eq (HTMLAnchorElement) where
+  (HTMLAnchorElement a) == (HTMLAnchorElement b) = js_eq a b
+
+instance PToJSVal HTMLAnchorElement where
+  pToJSVal = unHTMLAnchorElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal HTMLAnchorElement where
+  pFromJSVal = HTMLAnchorElement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal HTMLAnchorElement where
+  toJSVal = return . unHTMLAnchorElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal HTMLAnchorElement where
+  fromJSVal = return . fmap HTMLAnchorElement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsHTMLElement HTMLAnchorElement
+instance IsElement HTMLAnchorElement
+instance IsNode HTMLAnchorElement
+instance IsEventTarget HTMLAnchorElement
+instance IsGObject HTMLAnchorElement where
+  typeGType _ = gTypeHTMLAnchorElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"HTMLAnchorElement\"]" gTypeHTMLAnchorElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.HTMLAppletElement".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.HTMLElement"
+--     * "GHCJS.DOM.Element"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/HTMLAppletElement Mozilla HTMLAppletElement documentation>
+newtype HTMLAppletElement = HTMLAppletElement { unHTMLAppletElement :: JSVal }
+
+instance Eq (HTMLAppletElement) where
+  (HTMLAppletElement a) == (HTMLAppletElement b) = js_eq a b
+
+instance PToJSVal HTMLAppletElement where
+  pToJSVal = unHTMLAppletElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal HTMLAppletElement where
+  pFromJSVal = HTMLAppletElement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal HTMLAppletElement where
+  toJSVal = return . unHTMLAppletElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal HTMLAppletElement where
+  fromJSVal = return . fmap HTMLAppletElement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsHTMLElement HTMLAppletElement
+instance IsElement HTMLAppletElement
+instance IsNode HTMLAppletElement
+instance IsEventTarget HTMLAppletElement
+instance IsGObject HTMLAppletElement where
+  typeGType _ = gTypeHTMLAppletElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"HTMLAppletElement\"]" gTypeHTMLAppletElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.HTMLAreaElement".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.HTMLElement"
+--     * "GHCJS.DOM.Element"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/HTMLAreaElement Mozilla HTMLAreaElement documentation>
+newtype HTMLAreaElement = HTMLAreaElement { unHTMLAreaElement :: JSVal }
+
+instance Eq (HTMLAreaElement) where
+  (HTMLAreaElement a) == (HTMLAreaElement b) = js_eq a b
+
+instance PToJSVal HTMLAreaElement where
+  pToJSVal = unHTMLAreaElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal HTMLAreaElement where
+  pFromJSVal = HTMLAreaElement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal HTMLAreaElement where
+  toJSVal = return . unHTMLAreaElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal HTMLAreaElement where
+  fromJSVal = return . fmap HTMLAreaElement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsHTMLElement HTMLAreaElement
+instance IsElement HTMLAreaElement
+instance IsNode HTMLAreaElement
+instance IsEventTarget HTMLAreaElement
+instance IsGObject HTMLAreaElement where
+  typeGType _ = gTypeHTMLAreaElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"HTMLAreaElement\"]" gTypeHTMLAreaElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.HTMLAudioElement".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.HTMLMediaElement"
+--     * "GHCJS.DOM.HTMLElement"
+--     * "GHCJS.DOM.Element"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/HTMLAudioElement Mozilla HTMLAudioElement documentation>
+newtype HTMLAudioElement = HTMLAudioElement { unHTMLAudioElement :: JSVal }
+
+instance Eq (HTMLAudioElement) where
+  (HTMLAudioElement a) == (HTMLAudioElement b) = js_eq a b
+
+instance PToJSVal HTMLAudioElement where
+  pToJSVal = unHTMLAudioElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal HTMLAudioElement where
+  pFromJSVal = HTMLAudioElement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal HTMLAudioElement where
+  toJSVal = return . unHTMLAudioElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal HTMLAudioElement where
+  fromJSVal = return . fmap HTMLAudioElement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsHTMLMediaElement HTMLAudioElement
+instance IsHTMLElement HTMLAudioElement
+instance IsElement HTMLAudioElement
+instance IsNode HTMLAudioElement
+instance IsEventTarget HTMLAudioElement
+instance IsGObject HTMLAudioElement where
+  typeGType _ = gTypeHTMLAudioElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"HTMLAudioElement\"]" gTypeHTMLAudioElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.HTMLBRElement".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.HTMLElement"
+--     * "GHCJS.DOM.Element"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/HTMLBRElement Mozilla HTMLBRElement documentation>
+newtype HTMLBRElement = HTMLBRElement { unHTMLBRElement :: JSVal }
+
+instance Eq (HTMLBRElement) where
+  (HTMLBRElement a) == (HTMLBRElement b) = js_eq a b
+
+instance PToJSVal HTMLBRElement where
+  pToJSVal = unHTMLBRElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal HTMLBRElement where
+  pFromJSVal = HTMLBRElement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal HTMLBRElement where
+  toJSVal = return . unHTMLBRElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal HTMLBRElement where
+  fromJSVal = return . fmap HTMLBRElement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsHTMLElement HTMLBRElement
+instance IsElement HTMLBRElement
+instance IsNode HTMLBRElement
+instance IsEventTarget HTMLBRElement
+instance IsGObject HTMLBRElement where
+  typeGType _ = gTypeHTMLBRElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"HTMLBRElement\"]" gTypeHTMLBRElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.HTMLBaseElement".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.HTMLElement"
+--     * "GHCJS.DOM.Element"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/HTMLBaseElement Mozilla HTMLBaseElement documentation>
+newtype HTMLBaseElement = HTMLBaseElement { unHTMLBaseElement :: JSVal }
+
+instance Eq (HTMLBaseElement) where
+  (HTMLBaseElement a) == (HTMLBaseElement b) = js_eq a b
+
+instance PToJSVal HTMLBaseElement where
+  pToJSVal = unHTMLBaseElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal HTMLBaseElement where
+  pFromJSVal = HTMLBaseElement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal HTMLBaseElement where
+  toJSVal = return . unHTMLBaseElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal HTMLBaseElement where
+  fromJSVal = return . fmap HTMLBaseElement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsHTMLElement HTMLBaseElement
+instance IsElement HTMLBaseElement
+instance IsNode HTMLBaseElement
+instance IsEventTarget HTMLBaseElement
+instance IsGObject HTMLBaseElement where
+  typeGType _ = gTypeHTMLBaseElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"HTMLBaseElement\"]" gTypeHTMLBaseElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.HTMLBaseFontElement".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.HTMLElement"
+--     * "GHCJS.DOM.Element"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/HTMLBaseFontElement Mozilla HTMLBaseFontElement documentation>
+newtype HTMLBaseFontElement = HTMLBaseFontElement { unHTMLBaseFontElement :: JSVal }
+
+instance Eq (HTMLBaseFontElement) where
+  (HTMLBaseFontElement a) == (HTMLBaseFontElement b) = js_eq a b
+
+instance PToJSVal HTMLBaseFontElement where
+  pToJSVal = unHTMLBaseFontElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal HTMLBaseFontElement where
+  pFromJSVal = HTMLBaseFontElement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal HTMLBaseFontElement where
+  toJSVal = return . unHTMLBaseFontElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal HTMLBaseFontElement where
+  fromJSVal = return . fmap HTMLBaseFontElement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsHTMLElement HTMLBaseFontElement
+instance IsElement HTMLBaseFontElement
+instance IsNode HTMLBaseFontElement
+instance IsEventTarget HTMLBaseFontElement
+instance IsGObject HTMLBaseFontElement where
+  typeGType _ = gTypeHTMLBaseFontElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"HTMLBaseFontElement\"]" gTypeHTMLBaseFontElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.HTMLBodyElement".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.HTMLElement"
+--     * "GHCJS.DOM.Element"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/HTMLBodyElement Mozilla HTMLBodyElement documentation>
+newtype HTMLBodyElement = HTMLBodyElement { unHTMLBodyElement :: JSVal }
+
+instance Eq (HTMLBodyElement) where
+  (HTMLBodyElement a) == (HTMLBodyElement b) = js_eq a b
+
+instance PToJSVal HTMLBodyElement where
+  pToJSVal = unHTMLBodyElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal HTMLBodyElement where
+  pFromJSVal = HTMLBodyElement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal HTMLBodyElement where
+  toJSVal = return . unHTMLBodyElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal HTMLBodyElement where
+  fromJSVal = return . fmap HTMLBodyElement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsHTMLElement HTMLBodyElement
+instance IsElement HTMLBodyElement
+instance IsNode HTMLBodyElement
+instance IsEventTarget HTMLBodyElement
+instance IsGObject HTMLBodyElement where
+  typeGType _ = gTypeHTMLBodyElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"HTMLBodyElement\"]" gTypeHTMLBodyElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.HTMLButtonElement".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.HTMLElement"
+--     * "GHCJS.DOM.Element"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/HTMLButtonElement Mozilla HTMLButtonElement documentation>
+newtype HTMLButtonElement = HTMLButtonElement { unHTMLButtonElement :: JSVal }
+
+instance Eq (HTMLButtonElement) where
+  (HTMLButtonElement a) == (HTMLButtonElement b) = js_eq a b
+
+instance PToJSVal HTMLButtonElement where
+  pToJSVal = unHTMLButtonElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal HTMLButtonElement where
+  pFromJSVal = HTMLButtonElement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal HTMLButtonElement where
+  toJSVal = return . unHTMLButtonElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal HTMLButtonElement where
+  fromJSVal = return . fmap HTMLButtonElement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsHTMLElement HTMLButtonElement
+instance IsElement HTMLButtonElement
+instance IsNode HTMLButtonElement
+instance IsEventTarget HTMLButtonElement
+instance IsGObject HTMLButtonElement where
+  typeGType _ = gTypeHTMLButtonElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"HTMLButtonElement\"]" gTypeHTMLButtonElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.HTMLCanvasElement".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.HTMLElement"
+--     * "GHCJS.DOM.Element"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/HTMLCanvasElement Mozilla HTMLCanvasElement documentation>
+newtype HTMLCanvasElement = HTMLCanvasElement { unHTMLCanvasElement :: JSVal }
+
+instance Eq (HTMLCanvasElement) where
+  (HTMLCanvasElement a) == (HTMLCanvasElement b) = js_eq a b
+
+instance PToJSVal HTMLCanvasElement where
+  pToJSVal = unHTMLCanvasElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal HTMLCanvasElement where
+  pFromJSVal = HTMLCanvasElement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal HTMLCanvasElement where
+  toJSVal = return . unHTMLCanvasElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal HTMLCanvasElement where
+  fromJSVal = return . fmap HTMLCanvasElement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsHTMLElement HTMLCanvasElement
+instance IsElement HTMLCanvasElement
+instance IsNode HTMLCanvasElement
+instance IsEventTarget HTMLCanvasElement
+instance IsGObject HTMLCanvasElement where
+  typeGType _ = gTypeHTMLCanvasElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"HTMLCanvasElement\"]" gTypeHTMLCanvasElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.HTMLCollection".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/HTMLCollection Mozilla HTMLCollection documentation>
+newtype HTMLCollection = HTMLCollection { unHTMLCollection :: JSVal }
+
+instance Eq (HTMLCollection) where
+  (HTMLCollection a) == (HTMLCollection b) = js_eq a b
+
+instance PToJSVal HTMLCollection where
+  pToJSVal = unHTMLCollection
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal HTMLCollection where
+  pFromJSVal = HTMLCollection
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal HTMLCollection where
+  toJSVal = return . unHTMLCollection
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal HTMLCollection where
+  fromJSVal = return . fmap HTMLCollection . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+class IsGObject o => IsHTMLCollection o
+toHTMLCollection :: IsHTMLCollection o => o -> HTMLCollection
+toHTMLCollection = HTMLCollection . coerce
+
+instance IsHTMLCollection HTMLCollection
+instance IsGObject HTMLCollection where
+  typeGType _ = gTypeHTMLCollection
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"HTMLCollection\"]" gTypeHTMLCollection :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.HTMLDListElement".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.HTMLElement"
+--     * "GHCJS.DOM.Element"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/HTMLDListElement Mozilla HTMLDListElement documentation>
+newtype HTMLDListElement = HTMLDListElement { unHTMLDListElement :: JSVal }
+
+instance Eq (HTMLDListElement) where
+  (HTMLDListElement a) == (HTMLDListElement b) = js_eq a b
+
+instance PToJSVal HTMLDListElement where
+  pToJSVal = unHTMLDListElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal HTMLDListElement where
+  pFromJSVal = HTMLDListElement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal HTMLDListElement where
+  toJSVal = return . unHTMLDListElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal HTMLDListElement where
+  fromJSVal = return . fmap HTMLDListElement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsHTMLElement HTMLDListElement
+instance IsElement HTMLDListElement
+instance IsNode HTMLDListElement
+instance IsEventTarget HTMLDListElement
+instance IsGObject HTMLDListElement where
+  typeGType _ = gTypeHTMLDListElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"HTMLDListElement\"]" gTypeHTMLDListElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.HTMLDataListElement".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.HTMLElement"
+--     * "GHCJS.DOM.Element"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/HTMLDataListElement Mozilla HTMLDataListElement documentation>
+newtype HTMLDataListElement = HTMLDataListElement { unHTMLDataListElement :: JSVal }
+
+instance Eq (HTMLDataListElement) where
+  (HTMLDataListElement a) == (HTMLDataListElement b) = js_eq a b
+
+instance PToJSVal HTMLDataListElement where
+  pToJSVal = unHTMLDataListElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal HTMLDataListElement where
+  pFromJSVal = HTMLDataListElement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal HTMLDataListElement where
+  toJSVal = return . unHTMLDataListElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal HTMLDataListElement where
+  fromJSVal = return . fmap HTMLDataListElement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsHTMLElement HTMLDataListElement
+instance IsElement HTMLDataListElement
+instance IsNode HTMLDataListElement
+instance IsEventTarget HTMLDataListElement
+instance IsGObject HTMLDataListElement where
+  typeGType _ = gTypeHTMLDataListElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"HTMLDataListElement\"]" gTypeHTMLDataListElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.HTMLDetailsElement".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.HTMLElement"
+--     * "GHCJS.DOM.Element"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/HTMLDetailsElement Mozilla HTMLDetailsElement documentation>
+newtype HTMLDetailsElement = HTMLDetailsElement { unHTMLDetailsElement :: JSVal }
+
+instance Eq (HTMLDetailsElement) where
+  (HTMLDetailsElement a) == (HTMLDetailsElement b) = js_eq a b
+
+instance PToJSVal HTMLDetailsElement where
+  pToJSVal = unHTMLDetailsElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal HTMLDetailsElement where
+  pFromJSVal = HTMLDetailsElement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal HTMLDetailsElement where
+  toJSVal = return . unHTMLDetailsElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal HTMLDetailsElement where
+  fromJSVal = return . fmap HTMLDetailsElement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsHTMLElement HTMLDetailsElement
+instance IsElement HTMLDetailsElement
+instance IsNode HTMLDetailsElement
+instance IsEventTarget HTMLDetailsElement
+instance IsGObject HTMLDetailsElement where
+  typeGType _ = gTypeHTMLDetailsElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"HTMLDetailsElement\"]" gTypeHTMLDetailsElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.HTMLDirectoryElement".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.HTMLElement"
+--     * "GHCJS.DOM.Element"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/HTMLDirectoryElement Mozilla HTMLDirectoryElement documentation>
+newtype HTMLDirectoryElement = HTMLDirectoryElement { unHTMLDirectoryElement :: JSVal }
+
+instance Eq (HTMLDirectoryElement) where
+  (HTMLDirectoryElement a) == (HTMLDirectoryElement b) = js_eq a b
+
+instance PToJSVal HTMLDirectoryElement where
+  pToJSVal = unHTMLDirectoryElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal HTMLDirectoryElement where
+  pFromJSVal = HTMLDirectoryElement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal HTMLDirectoryElement where
+  toJSVal = return . unHTMLDirectoryElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal HTMLDirectoryElement where
+  fromJSVal = return . fmap HTMLDirectoryElement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsHTMLElement HTMLDirectoryElement
+instance IsElement HTMLDirectoryElement
+instance IsNode HTMLDirectoryElement
+instance IsEventTarget HTMLDirectoryElement
+instance IsGObject HTMLDirectoryElement where
+  typeGType _ = gTypeHTMLDirectoryElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"HTMLDirectoryElement\"]" gTypeHTMLDirectoryElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.HTMLDivElement".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.HTMLElement"
+--     * "GHCJS.DOM.Element"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/HTMLDivElement Mozilla HTMLDivElement documentation>
+newtype HTMLDivElement = HTMLDivElement { unHTMLDivElement :: JSVal }
+
+instance Eq (HTMLDivElement) where
+  (HTMLDivElement a) == (HTMLDivElement b) = js_eq a b
+
+instance PToJSVal HTMLDivElement where
+  pToJSVal = unHTMLDivElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal HTMLDivElement where
+  pFromJSVal = HTMLDivElement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal HTMLDivElement where
+  toJSVal = return . unHTMLDivElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal HTMLDivElement where
+  fromJSVal = return . fmap HTMLDivElement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsHTMLElement HTMLDivElement
+instance IsElement HTMLDivElement
+instance IsNode HTMLDivElement
+instance IsEventTarget HTMLDivElement
+instance IsGObject HTMLDivElement where
+  typeGType _ = gTypeHTMLDivElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"HTMLDivElement\"]" gTypeHTMLDivElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.HTMLDocument".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.Document"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/HTMLDocument Mozilla HTMLDocument documentation>
+newtype HTMLDocument = HTMLDocument { unHTMLDocument :: JSVal }
+
+instance Eq (HTMLDocument) where
+  (HTMLDocument a) == (HTMLDocument b) = js_eq a b
+
+instance PToJSVal HTMLDocument where
+  pToJSVal = unHTMLDocument
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal HTMLDocument where
+  pFromJSVal = HTMLDocument
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal HTMLDocument where
+  toJSVal = return . unHTMLDocument
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal HTMLDocument where
+  fromJSVal = return . fmap HTMLDocument . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsDocument HTMLDocument
+instance IsNode HTMLDocument
+instance IsEventTarget HTMLDocument
+instance IsGObject HTMLDocument where
+  typeGType _ = gTypeHTMLDocument
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"HTMLDocument\"]" gTypeHTMLDocument :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.HTMLElement".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.Element"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement Mozilla HTMLElement documentation>
+newtype HTMLElement = HTMLElement { unHTMLElement :: JSVal }
+
+instance Eq (HTMLElement) where
+  (HTMLElement a) == (HTMLElement b) = js_eq a b
+
+instance PToJSVal HTMLElement where
+  pToJSVal = unHTMLElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal HTMLElement where
+  pFromJSVal = HTMLElement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal HTMLElement where
+  toJSVal = return . unHTMLElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal HTMLElement where
+  fromJSVal = return . fmap HTMLElement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+class IsElement o => IsHTMLElement o
+toHTMLElement :: IsHTMLElement o => o -> HTMLElement
+toHTMLElement = HTMLElement . coerce
+
+instance IsHTMLElement HTMLElement
+instance IsElement HTMLElement
+instance IsNode HTMLElement
+instance IsEventTarget HTMLElement
+instance IsGObject HTMLElement where
+  typeGType _ = gTypeHTMLElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"HTMLElement\"]" gTypeHTMLElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.HTMLEmbedElement".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.HTMLElement"
+--     * "GHCJS.DOM.Element"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/HTMLEmbedElement Mozilla HTMLEmbedElement documentation>
+newtype HTMLEmbedElement = HTMLEmbedElement { unHTMLEmbedElement :: JSVal }
+
+instance Eq (HTMLEmbedElement) where
+  (HTMLEmbedElement a) == (HTMLEmbedElement b) = js_eq a b
+
+instance PToJSVal HTMLEmbedElement where
+  pToJSVal = unHTMLEmbedElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal HTMLEmbedElement where
+  pFromJSVal = HTMLEmbedElement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal HTMLEmbedElement where
+  toJSVal = return . unHTMLEmbedElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal HTMLEmbedElement where
+  fromJSVal = return . fmap HTMLEmbedElement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsHTMLElement HTMLEmbedElement
+instance IsElement HTMLEmbedElement
+instance IsNode HTMLEmbedElement
+instance IsEventTarget HTMLEmbedElement
+instance IsGObject HTMLEmbedElement where
+  typeGType _ = gTypeHTMLEmbedElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"HTMLEmbedElement\"]" gTypeHTMLEmbedElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.HTMLFieldSetElement".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.HTMLElement"
+--     * "GHCJS.DOM.Element"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/HTMLFieldSetElement Mozilla HTMLFieldSetElement documentation>
+newtype HTMLFieldSetElement = HTMLFieldSetElement { unHTMLFieldSetElement :: JSVal }
+
+instance Eq (HTMLFieldSetElement) where
+  (HTMLFieldSetElement a) == (HTMLFieldSetElement b) = js_eq a b
+
+instance PToJSVal HTMLFieldSetElement where
+  pToJSVal = unHTMLFieldSetElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal HTMLFieldSetElement where
+  pFromJSVal = HTMLFieldSetElement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal HTMLFieldSetElement where
+  toJSVal = return . unHTMLFieldSetElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal HTMLFieldSetElement where
+  fromJSVal = return . fmap HTMLFieldSetElement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsHTMLElement HTMLFieldSetElement
+instance IsElement HTMLFieldSetElement
+instance IsNode HTMLFieldSetElement
+instance IsEventTarget HTMLFieldSetElement
+instance IsGObject HTMLFieldSetElement where
+  typeGType _ = gTypeHTMLFieldSetElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"HTMLFieldSetElement\"]" gTypeHTMLFieldSetElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.HTMLFontElement".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.HTMLElement"
+--     * "GHCJS.DOM.Element"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/HTMLFontElement Mozilla HTMLFontElement documentation>
+newtype HTMLFontElement = HTMLFontElement { unHTMLFontElement :: JSVal }
+
+instance Eq (HTMLFontElement) where
+  (HTMLFontElement a) == (HTMLFontElement b) = js_eq a b
+
+instance PToJSVal HTMLFontElement where
+  pToJSVal = unHTMLFontElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal HTMLFontElement where
+  pFromJSVal = HTMLFontElement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal HTMLFontElement where
+  toJSVal = return . unHTMLFontElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal HTMLFontElement where
+  fromJSVal = return . fmap HTMLFontElement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsHTMLElement HTMLFontElement
+instance IsElement HTMLFontElement
+instance IsNode HTMLFontElement
+instance IsEventTarget HTMLFontElement
+instance IsGObject HTMLFontElement where
+  typeGType _ = gTypeHTMLFontElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"HTMLFontElement\"]" gTypeHTMLFontElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.HTMLFormControlsCollection".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.HTMLCollection"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/HTMLFormControlsCollection Mozilla HTMLFormControlsCollection documentation>
+newtype HTMLFormControlsCollection = HTMLFormControlsCollection { unHTMLFormControlsCollection :: JSVal }
+
+instance Eq (HTMLFormControlsCollection) where
+  (HTMLFormControlsCollection a) == (HTMLFormControlsCollection b) = js_eq a b
+
+instance PToJSVal HTMLFormControlsCollection where
+  pToJSVal = unHTMLFormControlsCollection
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal HTMLFormControlsCollection where
+  pFromJSVal = HTMLFormControlsCollection
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal HTMLFormControlsCollection where
+  toJSVal = return . unHTMLFormControlsCollection
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal HTMLFormControlsCollection where
+  fromJSVal = return . fmap HTMLFormControlsCollection . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsHTMLCollection HTMLFormControlsCollection
+instance IsGObject HTMLFormControlsCollection where
+  typeGType _ = gTypeHTMLFormControlsCollection
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"HTMLFormControlsCollection\"]" gTypeHTMLFormControlsCollection :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.HTMLFormElement".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.HTMLElement"
+--     * "GHCJS.DOM.Element"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/HTMLFormElement Mozilla HTMLFormElement documentation>
+newtype HTMLFormElement = HTMLFormElement { unHTMLFormElement :: JSVal }
+
+instance Eq (HTMLFormElement) where
+  (HTMLFormElement a) == (HTMLFormElement b) = js_eq a b
+
+instance PToJSVal HTMLFormElement where
+  pToJSVal = unHTMLFormElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal HTMLFormElement where
+  pFromJSVal = HTMLFormElement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal HTMLFormElement where
+  toJSVal = return . unHTMLFormElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal HTMLFormElement where
+  fromJSVal = return . fmap HTMLFormElement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsHTMLElement HTMLFormElement
+instance IsElement HTMLFormElement
+instance IsNode HTMLFormElement
+instance IsEventTarget HTMLFormElement
+instance IsGObject HTMLFormElement where
+  typeGType _ = gTypeHTMLFormElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"HTMLFormElement\"]" gTypeHTMLFormElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.HTMLFrameElement".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.HTMLElement"
+--     * "GHCJS.DOM.Element"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/HTMLFrameElement Mozilla HTMLFrameElement documentation>
+newtype HTMLFrameElement = HTMLFrameElement { unHTMLFrameElement :: JSVal }
+
+instance Eq (HTMLFrameElement) where
+  (HTMLFrameElement a) == (HTMLFrameElement b) = js_eq a b
+
+instance PToJSVal HTMLFrameElement where
+  pToJSVal = unHTMLFrameElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal HTMLFrameElement where
+  pFromJSVal = HTMLFrameElement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal HTMLFrameElement where
+  toJSVal = return . unHTMLFrameElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal HTMLFrameElement where
+  fromJSVal = return . fmap HTMLFrameElement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsHTMLElement HTMLFrameElement
+instance IsElement HTMLFrameElement
+instance IsNode HTMLFrameElement
+instance IsEventTarget HTMLFrameElement
+instance IsGObject HTMLFrameElement where
+  typeGType _ = gTypeHTMLFrameElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"HTMLFrameElement\"]" gTypeHTMLFrameElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.HTMLFrameSetElement".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.HTMLElement"
+--     * "GHCJS.DOM.Element"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/HTMLFrameSetElement Mozilla HTMLFrameSetElement documentation>
+newtype HTMLFrameSetElement = HTMLFrameSetElement { unHTMLFrameSetElement :: JSVal }
+
+instance Eq (HTMLFrameSetElement) where
+  (HTMLFrameSetElement a) == (HTMLFrameSetElement b) = js_eq a b
+
+instance PToJSVal HTMLFrameSetElement where
+  pToJSVal = unHTMLFrameSetElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal HTMLFrameSetElement where
+  pFromJSVal = HTMLFrameSetElement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal HTMLFrameSetElement where
+  toJSVal = return . unHTMLFrameSetElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal HTMLFrameSetElement where
+  fromJSVal = return . fmap HTMLFrameSetElement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsHTMLElement HTMLFrameSetElement
+instance IsElement HTMLFrameSetElement
+instance IsNode HTMLFrameSetElement
+instance IsEventTarget HTMLFrameSetElement
+instance IsGObject HTMLFrameSetElement where
+  typeGType _ = gTypeHTMLFrameSetElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"HTMLFrameSetElement\"]" gTypeHTMLFrameSetElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.HTMLHRElement".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.HTMLElement"
+--     * "GHCJS.DOM.Element"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/HTMLHRElement Mozilla HTMLHRElement documentation>
+newtype HTMLHRElement = HTMLHRElement { unHTMLHRElement :: JSVal }
+
+instance Eq (HTMLHRElement) where
+  (HTMLHRElement a) == (HTMLHRElement b) = js_eq a b
+
+instance PToJSVal HTMLHRElement where
+  pToJSVal = unHTMLHRElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal HTMLHRElement where
+  pFromJSVal = HTMLHRElement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal HTMLHRElement where
+  toJSVal = return . unHTMLHRElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal HTMLHRElement where
+  fromJSVal = return . fmap HTMLHRElement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsHTMLElement HTMLHRElement
+instance IsElement HTMLHRElement
+instance IsNode HTMLHRElement
+instance IsEventTarget HTMLHRElement
+instance IsGObject HTMLHRElement where
+  typeGType _ = gTypeHTMLHRElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"HTMLHRElement\"]" gTypeHTMLHRElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.HTMLHeadElement".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.HTMLElement"
+--     * "GHCJS.DOM.Element"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/HTMLHeadElement Mozilla HTMLHeadElement documentation>
+newtype HTMLHeadElement = HTMLHeadElement { unHTMLHeadElement :: JSVal }
+
+instance Eq (HTMLHeadElement) where
+  (HTMLHeadElement a) == (HTMLHeadElement b) = js_eq a b
+
+instance PToJSVal HTMLHeadElement where
+  pToJSVal = unHTMLHeadElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal HTMLHeadElement where
+  pFromJSVal = HTMLHeadElement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal HTMLHeadElement where
+  toJSVal = return . unHTMLHeadElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal HTMLHeadElement where
+  fromJSVal = return . fmap HTMLHeadElement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsHTMLElement HTMLHeadElement
+instance IsElement HTMLHeadElement
+instance IsNode HTMLHeadElement
+instance IsEventTarget HTMLHeadElement
+instance IsGObject HTMLHeadElement where
+  typeGType _ = gTypeHTMLHeadElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"HTMLHeadElement\"]" gTypeHTMLHeadElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.HTMLHeadingElement".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.HTMLElement"
+--     * "GHCJS.DOM.Element"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/HTMLHeadingElement Mozilla HTMLHeadingElement documentation>
+newtype HTMLHeadingElement = HTMLHeadingElement { unHTMLHeadingElement :: JSVal }
+
+instance Eq (HTMLHeadingElement) where
+  (HTMLHeadingElement a) == (HTMLHeadingElement b) = js_eq a b
+
+instance PToJSVal HTMLHeadingElement where
+  pToJSVal = unHTMLHeadingElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal HTMLHeadingElement where
+  pFromJSVal = HTMLHeadingElement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal HTMLHeadingElement where
+  toJSVal = return . unHTMLHeadingElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal HTMLHeadingElement where
+  fromJSVal = return . fmap HTMLHeadingElement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsHTMLElement HTMLHeadingElement
+instance IsElement HTMLHeadingElement
+instance IsNode HTMLHeadingElement
+instance IsEventTarget HTMLHeadingElement
+instance IsGObject HTMLHeadingElement where
+  typeGType _ = gTypeHTMLHeadingElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"HTMLHeadingElement\"]" gTypeHTMLHeadingElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.HTMLHtmlElement".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.HTMLElement"
+--     * "GHCJS.DOM.Element"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/HTMLHtmlElement Mozilla HTMLHtmlElement documentation>
+newtype HTMLHtmlElement = HTMLHtmlElement { unHTMLHtmlElement :: JSVal }
+
+instance Eq (HTMLHtmlElement) where
+  (HTMLHtmlElement a) == (HTMLHtmlElement b) = js_eq a b
+
+instance PToJSVal HTMLHtmlElement where
+  pToJSVal = unHTMLHtmlElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal HTMLHtmlElement where
+  pFromJSVal = HTMLHtmlElement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal HTMLHtmlElement where
+  toJSVal = return . unHTMLHtmlElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal HTMLHtmlElement where
+  fromJSVal = return . fmap HTMLHtmlElement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsHTMLElement HTMLHtmlElement
+instance IsElement HTMLHtmlElement
+instance IsNode HTMLHtmlElement
+instance IsEventTarget HTMLHtmlElement
+instance IsGObject HTMLHtmlElement where
+  typeGType _ = gTypeHTMLHtmlElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"HTMLHtmlElement\"]" gTypeHTMLHtmlElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.HTMLIFrameElement".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.HTMLElement"
+--     * "GHCJS.DOM.Element"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/HTMLIFrameElement Mozilla HTMLIFrameElement documentation>
+newtype HTMLIFrameElement = HTMLIFrameElement { unHTMLIFrameElement :: JSVal }
+
+instance Eq (HTMLIFrameElement) where
+  (HTMLIFrameElement a) == (HTMLIFrameElement b) = js_eq a b
+
+instance PToJSVal HTMLIFrameElement where
+  pToJSVal = unHTMLIFrameElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal HTMLIFrameElement where
+  pFromJSVal = HTMLIFrameElement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal HTMLIFrameElement where
+  toJSVal = return . unHTMLIFrameElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal HTMLIFrameElement where
+  fromJSVal = return . fmap HTMLIFrameElement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsHTMLElement HTMLIFrameElement
+instance IsElement HTMLIFrameElement
+instance IsNode HTMLIFrameElement
+instance IsEventTarget HTMLIFrameElement
+instance IsGObject HTMLIFrameElement where
+  typeGType _ = gTypeHTMLIFrameElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"HTMLIFrameElement\"]" gTypeHTMLIFrameElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.HTMLImageElement".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.HTMLElement"
+--     * "GHCJS.DOM.Element"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/HTMLImageElement Mozilla HTMLImageElement documentation>
+newtype HTMLImageElement = HTMLImageElement { unHTMLImageElement :: JSVal }
+
+instance Eq (HTMLImageElement) where
+  (HTMLImageElement a) == (HTMLImageElement b) = js_eq a b
+
+instance PToJSVal HTMLImageElement where
+  pToJSVal = unHTMLImageElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal HTMLImageElement where
+  pFromJSVal = HTMLImageElement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal HTMLImageElement where
+  toJSVal = return . unHTMLImageElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal HTMLImageElement where
+  fromJSVal = return . fmap HTMLImageElement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsHTMLElement HTMLImageElement
+instance IsElement HTMLImageElement
+instance IsNode HTMLImageElement
+instance IsEventTarget HTMLImageElement
+instance IsGObject HTMLImageElement where
+  typeGType _ = gTypeHTMLImageElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"HTMLImageElement\"]" gTypeHTMLImageElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.HTMLInputElement".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.HTMLElement"
+--     * "GHCJS.DOM.Element"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/HTMLInputElement Mozilla HTMLInputElement documentation>
+newtype HTMLInputElement = HTMLInputElement { unHTMLInputElement :: JSVal }
+
+instance Eq (HTMLInputElement) where
+  (HTMLInputElement a) == (HTMLInputElement b) = js_eq a b
+
+instance PToJSVal HTMLInputElement where
+  pToJSVal = unHTMLInputElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal HTMLInputElement where
+  pFromJSVal = HTMLInputElement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal HTMLInputElement where
+  toJSVal = return . unHTMLInputElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal HTMLInputElement where
+  fromJSVal = return . fmap HTMLInputElement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsHTMLElement HTMLInputElement
+instance IsElement HTMLInputElement
+instance IsNode HTMLInputElement
+instance IsEventTarget HTMLInputElement
+instance IsGObject HTMLInputElement where
+  typeGType _ = gTypeHTMLInputElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"HTMLInputElement\"]" gTypeHTMLInputElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.HTMLKeygenElement".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.HTMLElement"
+--     * "GHCJS.DOM.Element"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/HTMLKeygenElement Mozilla HTMLKeygenElement documentation>
+newtype HTMLKeygenElement = HTMLKeygenElement { unHTMLKeygenElement :: JSVal }
+
+instance Eq (HTMLKeygenElement) where
+  (HTMLKeygenElement a) == (HTMLKeygenElement b) = js_eq a b
+
+instance PToJSVal HTMLKeygenElement where
+  pToJSVal = unHTMLKeygenElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal HTMLKeygenElement where
+  pFromJSVal = HTMLKeygenElement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal HTMLKeygenElement where
+  toJSVal = return . unHTMLKeygenElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal HTMLKeygenElement where
+  fromJSVal = return . fmap HTMLKeygenElement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsHTMLElement HTMLKeygenElement
+instance IsElement HTMLKeygenElement
+instance IsNode HTMLKeygenElement
+instance IsEventTarget HTMLKeygenElement
+instance IsGObject HTMLKeygenElement where
+  typeGType _ = gTypeHTMLKeygenElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"HTMLKeygenElement\"]" gTypeHTMLKeygenElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.HTMLLIElement".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.HTMLElement"
+--     * "GHCJS.DOM.Element"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/HTMLLIElement Mozilla HTMLLIElement documentation>
+newtype HTMLLIElement = HTMLLIElement { unHTMLLIElement :: JSVal }
+
+instance Eq (HTMLLIElement) where
+  (HTMLLIElement a) == (HTMLLIElement b) = js_eq a b
+
+instance PToJSVal HTMLLIElement where
+  pToJSVal = unHTMLLIElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal HTMLLIElement where
+  pFromJSVal = HTMLLIElement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal HTMLLIElement where
+  toJSVal = return . unHTMLLIElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal HTMLLIElement where
+  fromJSVal = return . fmap HTMLLIElement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsHTMLElement HTMLLIElement
+instance IsElement HTMLLIElement
+instance IsNode HTMLLIElement
+instance IsEventTarget HTMLLIElement
+instance IsGObject HTMLLIElement where
+  typeGType _ = gTypeHTMLLIElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"HTMLLIElement\"]" gTypeHTMLLIElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.HTMLLabelElement".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.HTMLElement"
+--     * "GHCJS.DOM.Element"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/HTMLLabelElement Mozilla HTMLLabelElement documentation>
+newtype HTMLLabelElement = HTMLLabelElement { unHTMLLabelElement :: JSVal }
+
+instance Eq (HTMLLabelElement) where
+  (HTMLLabelElement a) == (HTMLLabelElement b) = js_eq a b
+
+instance PToJSVal HTMLLabelElement where
+  pToJSVal = unHTMLLabelElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal HTMLLabelElement where
+  pFromJSVal = HTMLLabelElement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal HTMLLabelElement where
+  toJSVal = return . unHTMLLabelElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal HTMLLabelElement where
+  fromJSVal = return . fmap HTMLLabelElement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsHTMLElement HTMLLabelElement
+instance IsElement HTMLLabelElement
+instance IsNode HTMLLabelElement
+instance IsEventTarget HTMLLabelElement
+instance IsGObject HTMLLabelElement where
+  typeGType _ = gTypeHTMLLabelElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"HTMLLabelElement\"]" gTypeHTMLLabelElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.HTMLLegendElement".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.HTMLElement"
+--     * "GHCJS.DOM.Element"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/HTMLLegendElement Mozilla HTMLLegendElement documentation>
+newtype HTMLLegendElement = HTMLLegendElement { unHTMLLegendElement :: JSVal }
+
+instance Eq (HTMLLegendElement) where
+  (HTMLLegendElement a) == (HTMLLegendElement b) = js_eq a b
+
+instance PToJSVal HTMLLegendElement where
+  pToJSVal = unHTMLLegendElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal HTMLLegendElement where
+  pFromJSVal = HTMLLegendElement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal HTMLLegendElement where
+  toJSVal = return . unHTMLLegendElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal HTMLLegendElement where
+  fromJSVal = return . fmap HTMLLegendElement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsHTMLElement HTMLLegendElement
+instance IsElement HTMLLegendElement
+instance IsNode HTMLLegendElement
+instance IsEventTarget HTMLLegendElement
+instance IsGObject HTMLLegendElement where
+  typeGType _ = gTypeHTMLLegendElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"HTMLLegendElement\"]" gTypeHTMLLegendElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.HTMLLinkElement".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.HTMLElement"
+--     * "GHCJS.DOM.Element"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/HTMLLinkElement Mozilla HTMLLinkElement documentation>
+newtype HTMLLinkElement = HTMLLinkElement { unHTMLLinkElement :: JSVal }
+
+instance Eq (HTMLLinkElement) where
+  (HTMLLinkElement a) == (HTMLLinkElement b) = js_eq a b
+
+instance PToJSVal HTMLLinkElement where
+  pToJSVal = unHTMLLinkElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal HTMLLinkElement where
+  pFromJSVal = HTMLLinkElement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal HTMLLinkElement where
+  toJSVal = return . unHTMLLinkElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal HTMLLinkElement where
+  fromJSVal = return . fmap HTMLLinkElement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsHTMLElement HTMLLinkElement
+instance IsElement HTMLLinkElement
+instance IsNode HTMLLinkElement
+instance IsEventTarget HTMLLinkElement
+instance IsGObject HTMLLinkElement where
+  typeGType _ = gTypeHTMLLinkElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"HTMLLinkElement\"]" gTypeHTMLLinkElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.HTMLMapElement".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.HTMLElement"
+--     * "GHCJS.DOM.Element"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/HTMLMapElement Mozilla HTMLMapElement documentation>
+newtype HTMLMapElement = HTMLMapElement { unHTMLMapElement :: JSVal }
+
+instance Eq (HTMLMapElement) where
+  (HTMLMapElement a) == (HTMLMapElement b) = js_eq a b
+
+instance PToJSVal HTMLMapElement where
+  pToJSVal = unHTMLMapElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal HTMLMapElement where
+  pFromJSVal = HTMLMapElement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal HTMLMapElement where
+  toJSVal = return . unHTMLMapElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal HTMLMapElement where
+  fromJSVal = return . fmap HTMLMapElement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsHTMLElement HTMLMapElement
+instance IsElement HTMLMapElement
+instance IsNode HTMLMapElement
+instance IsEventTarget HTMLMapElement
+instance IsGObject HTMLMapElement where
+  typeGType _ = gTypeHTMLMapElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"HTMLMapElement\"]" gTypeHTMLMapElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.HTMLMarqueeElement".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.HTMLElement"
+--     * "GHCJS.DOM.Element"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/HTMLMarqueeElement Mozilla HTMLMarqueeElement documentation>
+newtype HTMLMarqueeElement = HTMLMarqueeElement { unHTMLMarqueeElement :: JSVal }
+
+instance Eq (HTMLMarqueeElement) where
+  (HTMLMarqueeElement a) == (HTMLMarqueeElement b) = js_eq a b
+
+instance PToJSVal HTMLMarqueeElement where
+  pToJSVal = unHTMLMarqueeElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal HTMLMarqueeElement where
+  pFromJSVal = HTMLMarqueeElement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal HTMLMarqueeElement where
+  toJSVal = return . unHTMLMarqueeElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal HTMLMarqueeElement where
+  fromJSVal = return . fmap HTMLMarqueeElement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsHTMLElement HTMLMarqueeElement
+instance IsElement HTMLMarqueeElement
+instance IsNode HTMLMarqueeElement
+instance IsEventTarget HTMLMarqueeElement
+instance IsGObject HTMLMarqueeElement where
+  typeGType _ = gTypeHTMLMarqueeElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"HTMLMarqueeElement\"]" gTypeHTMLMarqueeElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.HTMLMediaElement".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.HTMLElement"
+--     * "GHCJS.DOM.Element"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/HTMLMediaElement Mozilla HTMLMediaElement documentation>
+newtype HTMLMediaElement = HTMLMediaElement { unHTMLMediaElement :: JSVal }
+
+instance Eq (HTMLMediaElement) where
+  (HTMLMediaElement a) == (HTMLMediaElement b) = js_eq a b
+
+instance PToJSVal HTMLMediaElement where
+  pToJSVal = unHTMLMediaElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal HTMLMediaElement where
+  pFromJSVal = HTMLMediaElement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal HTMLMediaElement where
+  toJSVal = return . unHTMLMediaElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal HTMLMediaElement where
+  fromJSVal = return . fmap HTMLMediaElement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+class IsHTMLElement o => IsHTMLMediaElement o
+toHTMLMediaElement :: IsHTMLMediaElement o => o -> HTMLMediaElement
+toHTMLMediaElement = HTMLMediaElement . coerce
+
+instance IsHTMLMediaElement HTMLMediaElement
+instance IsHTMLElement HTMLMediaElement
+instance IsElement HTMLMediaElement
+instance IsNode HTMLMediaElement
+instance IsEventTarget HTMLMediaElement
+instance IsGObject HTMLMediaElement where
+  typeGType _ = gTypeHTMLMediaElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"HTMLMediaElement\"]" gTypeHTMLMediaElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.HTMLMenuElement".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.HTMLElement"
+--     * "GHCJS.DOM.Element"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/HTMLMenuElement Mozilla HTMLMenuElement documentation>
+newtype HTMLMenuElement = HTMLMenuElement { unHTMLMenuElement :: JSVal }
+
+instance Eq (HTMLMenuElement) where
+  (HTMLMenuElement a) == (HTMLMenuElement b) = js_eq a b
+
+instance PToJSVal HTMLMenuElement where
+  pToJSVal = unHTMLMenuElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal HTMLMenuElement where
+  pFromJSVal = HTMLMenuElement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal HTMLMenuElement where
+  toJSVal = return . unHTMLMenuElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal HTMLMenuElement where
+  fromJSVal = return . fmap HTMLMenuElement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsHTMLElement HTMLMenuElement
+instance IsElement HTMLMenuElement
+instance IsNode HTMLMenuElement
+instance IsEventTarget HTMLMenuElement
+instance IsGObject HTMLMenuElement where
+  typeGType _ = gTypeHTMLMenuElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"HTMLMenuElement\"]" gTypeHTMLMenuElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.HTMLMetaElement".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.HTMLElement"
+--     * "GHCJS.DOM.Element"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/HTMLMetaElement Mozilla HTMLMetaElement documentation>
+newtype HTMLMetaElement = HTMLMetaElement { unHTMLMetaElement :: JSVal }
+
+instance Eq (HTMLMetaElement) where
+  (HTMLMetaElement a) == (HTMLMetaElement b) = js_eq a b
+
+instance PToJSVal HTMLMetaElement where
+  pToJSVal = unHTMLMetaElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal HTMLMetaElement where
+  pFromJSVal = HTMLMetaElement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal HTMLMetaElement where
+  toJSVal = return . unHTMLMetaElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal HTMLMetaElement where
+  fromJSVal = return . fmap HTMLMetaElement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsHTMLElement HTMLMetaElement
+instance IsElement HTMLMetaElement
+instance IsNode HTMLMetaElement
+instance IsEventTarget HTMLMetaElement
+instance IsGObject HTMLMetaElement where
+  typeGType _ = gTypeHTMLMetaElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"HTMLMetaElement\"]" gTypeHTMLMetaElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.HTMLMeterElement".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.HTMLElement"
+--     * "GHCJS.DOM.Element"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/HTMLMeterElement Mozilla HTMLMeterElement documentation>
+newtype HTMLMeterElement = HTMLMeterElement { unHTMLMeterElement :: JSVal }
+
+instance Eq (HTMLMeterElement) where
+  (HTMLMeterElement a) == (HTMLMeterElement b) = js_eq a b
+
+instance PToJSVal HTMLMeterElement where
+  pToJSVal = unHTMLMeterElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal HTMLMeterElement where
+  pFromJSVal = HTMLMeterElement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal HTMLMeterElement where
+  toJSVal = return . unHTMLMeterElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal HTMLMeterElement where
+  fromJSVal = return . fmap HTMLMeterElement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsHTMLElement HTMLMeterElement
+instance IsElement HTMLMeterElement
+instance IsNode HTMLMeterElement
+instance IsEventTarget HTMLMeterElement
+instance IsGObject HTMLMeterElement where
+  typeGType _ = gTypeHTMLMeterElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"HTMLMeterElement\"]" gTypeHTMLMeterElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.HTMLModElement".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.HTMLElement"
+--     * "GHCJS.DOM.Element"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/HTMLModElement Mozilla HTMLModElement documentation>
+newtype HTMLModElement = HTMLModElement { unHTMLModElement :: JSVal }
+
+instance Eq (HTMLModElement) where
+  (HTMLModElement a) == (HTMLModElement b) = js_eq a b
+
+instance PToJSVal HTMLModElement where
+  pToJSVal = unHTMLModElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal HTMLModElement where
+  pFromJSVal = HTMLModElement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal HTMLModElement where
+  toJSVal = return . unHTMLModElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal HTMLModElement where
+  fromJSVal = return . fmap HTMLModElement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsHTMLElement HTMLModElement
+instance IsElement HTMLModElement
+instance IsNode HTMLModElement
+instance IsEventTarget HTMLModElement
+instance IsGObject HTMLModElement where
+  typeGType _ = gTypeHTMLModElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"HTMLModElement\"]" gTypeHTMLModElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.HTMLOListElement".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.HTMLElement"
+--     * "GHCJS.DOM.Element"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/HTMLOListElement Mozilla HTMLOListElement documentation>
+newtype HTMLOListElement = HTMLOListElement { unHTMLOListElement :: JSVal }
+
+instance Eq (HTMLOListElement) where
+  (HTMLOListElement a) == (HTMLOListElement b) = js_eq a b
+
+instance PToJSVal HTMLOListElement where
+  pToJSVal = unHTMLOListElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal HTMLOListElement where
+  pFromJSVal = HTMLOListElement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal HTMLOListElement where
+  toJSVal = return . unHTMLOListElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal HTMLOListElement where
+  fromJSVal = return . fmap HTMLOListElement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsHTMLElement HTMLOListElement
+instance IsElement HTMLOListElement
+instance IsNode HTMLOListElement
+instance IsEventTarget HTMLOListElement
+instance IsGObject HTMLOListElement where
+  typeGType _ = gTypeHTMLOListElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"HTMLOListElement\"]" gTypeHTMLOListElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.HTMLObjectElement".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.HTMLElement"
+--     * "GHCJS.DOM.Element"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/HTMLObjectElement Mozilla HTMLObjectElement documentation>
+newtype HTMLObjectElement = HTMLObjectElement { unHTMLObjectElement :: JSVal }
+
+instance Eq (HTMLObjectElement) where
+  (HTMLObjectElement a) == (HTMLObjectElement b) = js_eq a b
+
+instance PToJSVal HTMLObjectElement where
+  pToJSVal = unHTMLObjectElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal HTMLObjectElement where
+  pFromJSVal = HTMLObjectElement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal HTMLObjectElement where
+  toJSVal = return . unHTMLObjectElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal HTMLObjectElement where
+  fromJSVal = return . fmap HTMLObjectElement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsHTMLElement HTMLObjectElement
+instance IsElement HTMLObjectElement
+instance IsNode HTMLObjectElement
+instance IsEventTarget HTMLObjectElement
+instance IsGObject HTMLObjectElement where
+  typeGType _ = gTypeHTMLObjectElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"HTMLObjectElement\"]" gTypeHTMLObjectElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.HTMLOptGroupElement".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.HTMLElement"
+--     * "GHCJS.DOM.Element"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/HTMLOptGroupElement Mozilla HTMLOptGroupElement documentation>
+newtype HTMLOptGroupElement = HTMLOptGroupElement { unHTMLOptGroupElement :: JSVal }
+
+instance Eq (HTMLOptGroupElement) where
+  (HTMLOptGroupElement a) == (HTMLOptGroupElement b) = js_eq a b
+
+instance PToJSVal HTMLOptGroupElement where
+  pToJSVal = unHTMLOptGroupElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal HTMLOptGroupElement where
+  pFromJSVal = HTMLOptGroupElement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal HTMLOptGroupElement where
+  toJSVal = return . unHTMLOptGroupElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal HTMLOptGroupElement where
+  fromJSVal = return . fmap HTMLOptGroupElement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsHTMLElement HTMLOptGroupElement
+instance IsElement HTMLOptGroupElement
+instance IsNode HTMLOptGroupElement
+instance IsEventTarget HTMLOptGroupElement
+instance IsGObject HTMLOptGroupElement where
+  typeGType _ = gTypeHTMLOptGroupElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"HTMLOptGroupElement\"]" gTypeHTMLOptGroupElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.HTMLOptionElement".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.HTMLElement"
+--     * "GHCJS.DOM.Element"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/HTMLOptionElement Mozilla HTMLOptionElement documentation>
+newtype HTMLOptionElement = HTMLOptionElement { unHTMLOptionElement :: JSVal }
+
+instance Eq (HTMLOptionElement) where
+  (HTMLOptionElement a) == (HTMLOptionElement b) = js_eq a b
+
+instance PToJSVal HTMLOptionElement where
+  pToJSVal = unHTMLOptionElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal HTMLOptionElement where
+  pFromJSVal = HTMLOptionElement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal HTMLOptionElement where
+  toJSVal = return . unHTMLOptionElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal HTMLOptionElement where
+  fromJSVal = return . fmap HTMLOptionElement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsHTMLElement HTMLOptionElement
+instance IsElement HTMLOptionElement
+instance IsNode HTMLOptionElement
+instance IsEventTarget HTMLOptionElement
+instance IsGObject HTMLOptionElement where
+  typeGType _ = gTypeHTMLOptionElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"HTMLOptionElement\"]" gTypeHTMLOptionElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.HTMLOptionsCollection".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.HTMLCollection"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/HTMLOptionsCollection Mozilla HTMLOptionsCollection documentation>
+newtype HTMLOptionsCollection = HTMLOptionsCollection { unHTMLOptionsCollection :: JSVal }
+
+instance Eq (HTMLOptionsCollection) where
+  (HTMLOptionsCollection a) == (HTMLOptionsCollection b) = js_eq a b
+
+instance PToJSVal HTMLOptionsCollection where
+  pToJSVal = unHTMLOptionsCollection
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal HTMLOptionsCollection where
+  pFromJSVal = HTMLOptionsCollection
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal HTMLOptionsCollection where
+  toJSVal = return . unHTMLOptionsCollection
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal HTMLOptionsCollection where
+  fromJSVal = return . fmap HTMLOptionsCollection . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsHTMLCollection HTMLOptionsCollection
+instance IsGObject HTMLOptionsCollection where
+  typeGType _ = gTypeHTMLOptionsCollection
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"HTMLOptionsCollection\"]" gTypeHTMLOptionsCollection :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.HTMLOutputElement".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.HTMLElement"
+--     * "GHCJS.DOM.Element"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/HTMLOutputElement Mozilla HTMLOutputElement documentation>
+newtype HTMLOutputElement = HTMLOutputElement { unHTMLOutputElement :: JSVal }
+
+instance Eq (HTMLOutputElement) where
+  (HTMLOutputElement a) == (HTMLOutputElement b) = js_eq a b
+
+instance PToJSVal HTMLOutputElement where
+  pToJSVal = unHTMLOutputElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal HTMLOutputElement where
+  pFromJSVal = HTMLOutputElement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal HTMLOutputElement where
+  toJSVal = return . unHTMLOutputElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal HTMLOutputElement where
+  fromJSVal = return . fmap HTMLOutputElement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsHTMLElement HTMLOutputElement
+instance IsElement HTMLOutputElement
+instance IsNode HTMLOutputElement
+instance IsEventTarget HTMLOutputElement
+instance IsGObject HTMLOutputElement where
+  typeGType _ = gTypeHTMLOutputElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"HTMLOutputElement\"]" gTypeHTMLOutputElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.HTMLParagraphElement".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.HTMLElement"
+--     * "GHCJS.DOM.Element"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/HTMLParagraphElement Mozilla HTMLParagraphElement documentation>
+newtype HTMLParagraphElement = HTMLParagraphElement { unHTMLParagraphElement :: JSVal }
+
+instance Eq (HTMLParagraphElement) where
+  (HTMLParagraphElement a) == (HTMLParagraphElement b) = js_eq a b
+
+instance PToJSVal HTMLParagraphElement where
+  pToJSVal = unHTMLParagraphElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal HTMLParagraphElement where
+  pFromJSVal = HTMLParagraphElement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal HTMLParagraphElement where
+  toJSVal = return . unHTMLParagraphElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal HTMLParagraphElement where
+  fromJSVal = return . fmap HTMLParagraphElement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsHTMLElement HTMLParagraphElement
+instance IsElement HTMLParagraphElement
+instance IsNode HTMLParagraphElement
+instance IsEventTarget HTMLParagraphElement
+instance IsGObject HTMLParagraphElement where
+  typeGType _ = gTypeHTMLParagraphElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"HTMLParagraphElement\"]" gTypeHTMLParagraphElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.HTMLParamElement".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.HTMLElement"
+--     * "GHCJS.DOM.Element"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/HTMLParamElement Mozilla HTMLParamElement documentation>
+newtype HTMLParamElement = HTMLParamElement { unHTMLParamElement :: JSVal }
+
+instance Eq (HTMLParamElement) where
+  (HTMLParamElement a) == (HTMLParamElement b) = js_eq a b
+
+instance PToJSVal HTMLParamElement where
+  pToJSVal = unHTMLParamElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal HTMLParamElement where
+  pFromJSVal = HTMLParamElement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal HTMLParamElement where
+  toJSVal = return . unHTMLParamElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal HTMLParamElement where
+  fromJSVal = return . fmap HTMLParamElement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsHTMLElement HTMLParamElement
+instance IsElement HTMLParamElement
+instance IsNode HTMLParamElement
+instance IsEventTarget HTMLParamElement
+instance IsGObject HTMLParamElement where
+  typeGType _ = gTypeHTMLParamElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"HTMLParamElement\"]" gTypeHTMLParamElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.HTMLPreElement".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.HTMLElement"
+--     * "GHCJS.DOM.Element"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/HTMLPreElement Mozilla HTMLPreElement documentation>
+newtype HTMLPreElement = HTMLPreElement { unHTMLPreElement :: JSVal }
+
+instance Eq (HTMLPreElement) where
+  (HTMLPreElement a) == (HTMLPreElement b) = js_eq a b
+
+instance PToJSVal HTMLPreElement where
+  pToJSVal = unHTMLPreElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal HTMLPreElement where
+  pFromJSVal = HTMLPreElement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal HTMLPreElement where
+  toJSVal = return . unHTMLPreElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal HTMLPreElement where
+  fromJSVal = return . fmap HTMLPreElement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsHTMLElement HTMLPreElement
+instance IsElement HTMLPreElement
+instance IsNode HTMLPreElement
+instance IsEventTarget HTMLPreElement
+instance IsGObject HTMLPreElement where
+  typeGType _ = gTypeHTMLPreElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"HTMLPreElement\"]" gTypeHTMLPreElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.HTMLProgressElement".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.HTMLElement"
+--     * "GHCJS.DOM.Element"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/HTMLProgressElement Mozilla HTMLProgressElement documentation>
+newtype HTMLProgressElement = HTMLProgressElement { unHTMLProgressElement :: JSVal }
+
+instance Eq (HTMLProgressElement) where
+  (HTMLProgressElement a) == (HTMLProgressElement b) = js_eq a b
+
+instance PToJSVal HTMLProgressElement where
+  pToJSVal = unHTMLProgressElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal HTMLProgressElement where
+  pFromJSVal = HTMLProgressElement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal HTMLProgressElement where
+  toJSVal = return . unHTMLProgressElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal HTMLProgressElement where
+  fromJSVal = return . fmap HTMLProgressElement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsHTMLElement HTMLProgressElement
+instance IsElement HTMLProgressElement
+instance IsNode HTMLProgressElement
+instance IsEventTarget HTMLProgressElement
+instance IsGObject HTMLProgressElement where
+  typeGType _ = gTypeHTMLProgressElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"HTMLProgressElement\"]" gTypeHTMLProgressElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.HTMLQuoteElement".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.HTMLElement"
+--     * "GHCJS.DOM.Element"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/HTMLQuoteElement Mozilla HTMLQuoteElement documentation>
+newtype HTMLQuoteElement = HTMLQuoteElement { unHTMLQuoteElement :: JSVal }
+
+instance Eq (HTMLQuoteElement) where
+  (HTMLQuoteElement a) == (HTMLQuoteElement b) = js_eq a b
+
+instance PToJSVal HTMLQuoteElement where
+  pToJSVal = unHTMLQuoteElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal HTMLQuoteElement where
+  pFromJSVal = HTMLQuoteElement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal HTMLQuoteElement where
+  toJSVal = return . unHTMLQuoteElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal HTMLQuoteElement where
+  fromJSVal = return . fmap HTMLQuoteElement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsHTMLElement HTMLQuoteElement
+instance IsElement HTMLQuoteElement
+instance IsNode HTMLQuoteElement
+instance IsEventTarget HTMLQuoteElement
+instance IsGObject HTMLQuoteElement where
+  typeGType _ = gTypeHTMLQuoteElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"HTMLQuoteElement\"]" gTypeHTMLQuoteElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.HTMLScriptElement".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.HTMLElement"
+--     * "GHCJS.DOM.Element"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/HTMLScriptElement Mozilla HTMLScriptElement documentation>
+newtype HTMLScriptElement = HTMLScriptElement { unHTMLScriptElement :: JSVal }
+
+instance Eq (HTMLScriptElement) where
+  (HTMLScriptElement a) == (HTMLScriptElement b) = js_eq a b
+
+instance PToJSVal HTMLScriptElement where
+  pToJSVal = unHTMLScriptElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal HTMLScriptElement where
+  pFromJSVal = HTMLScriptElement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal HTMLScriptElement where
+  toJSVal = return . unHTMLScriptElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal HTMLScriptElement where
+  fromJSVal = return . fmap HTMLScriptElement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsHTMLElement HTMLScriptElement
+instance IsElement HTMLScriptElement
+instance IsNode HTMLScriptElement
+instance IsEventTarget HTMLScriptElement
+instance IsGObject HTMLScriptElement where
+  typeGType _ = gTypeHTMLScriptElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"HTMLScriptElement\"]" gTypeHTMLScriptElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.HTMLSelectElement".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.HTMLElement"
+--     * "GHCJS.DOM.Element"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/HTMLSelectElement Mozilla HTMLSelectElement documentation>
+newtype HTMLSelectElement = HTMLSelectElement { unHTMLSelectElement :: JSVal }
+
+instance Eq (HTMLSelectElement) where
+  (HTMLSelectElement a) == (HTMLSelectElement b) = js_eq a b
+
+instance PToJSVal HTMLSelectElement where
+  pToJSVal = unHTMLSelectElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal HTMLSelectElement where
+  pFromJSVal = HTMLSelectElement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal HTMLSelectElement where
+  toJSVal = return . unHTMLSelectElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal HTMLSelectElement where
+  fromJSVal = return . fmap HTMLSelectElement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsHTMLElement HTMLSelectElement
+instance IsElement HTMLSelectElement
+instance IsNode HTMLSelectElement
+instance IsEventTarget HTMLSelectElement
+instance IsGObject HTMLSelectElement where
+  typeGType _ = gTypeHTMLSelectElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"HTMLSelectElement\"]" gTypeHTMLSelectElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.HTMLSourceElement".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.HTMLElement"
+--     * "GHCJS.DOM.Element"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/HTMLSourceElement Mozilla HTMLSourceElement documentation>
+newtype HTMLSourceElement = HTMLSourceElement { unHTMLSourceElement :: JSVal }
+
+instance Eq (HTMLSourceElement) where
+  (HTMLSourceElement a) == (HTMLSourceElement b) = js_eq a b
+
+instance PToJSVal HTMLSourceElement where
+  pToJSVal = unHTMLSourceElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal HTMLSourceElement where
+  pFromJSVal = HTMLSourceElement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal HTMLSourceElement where
+  toJSVal = return . unHTMLSourceElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal HTMLSourceElement where
+  fromJSVal = return . fmap HTMLSourceElement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsHTMLElement HTMLSourceElement
+instance IsElement HTMLSourceElement
+instance IsNode HTMLSourceElement
+instance IsEventTarget HTMLSourceElement
+instance IsGObject HTMLSourceElement where
+  typeGType _ = gTypeHTMLSourceElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"HTMLSourceElement\"]" gTypeHTMLSourceElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.HTMLSpanElement".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.HTMLElement"
+--     * "GHCJS.DOM.Element"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/HTMLSpanElement Mozilla HTMLSpanElement documentation>
+newtype HTMLSpanElement = HTMLSpanElement { unHTMLSpanElement :: JSVal }
+
+instance Eq (HTMLSpanElement) where
+  (HTMLSpanElement a) == (HTMLSpanElement b) = js_eq a b
+
+instance PToJSVal HTMLSpanElement where
+  pToJSVal = unHTMLSpanElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal HTMLSpanElement where
+  pFromJSVal = HTMLSpanElement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal HTMLSpanElement where
+  toJSVal = return . unHTMLSpanElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal HTMLSpanElement where
+  fromJSVal = return . fmap HTMLSpanElement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsHTMLElement HTMLSpanElement
+instance IsElement HTMLSpanElement
+instance IsNode HTMLSpanElement
+instance IsEventTarget HTMLSpanElement
+instance IsGObject HTMLSpanElement where
+  typeGType _ = gTypeHTMLSpanElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"HTMLSpanElement\"]" gTypeHTMLSpanElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.HTMLStyleElement".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.HTMLElement"
+--     * "GHCJS.DOM.Element"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/HTMLStyleElement Mozilla HTMLStyleElement documentation>
+newtype HTMLStyleElement = HTMLStyleElement { unHTMLStyleElement :: JSVal }
+
+instance Eq (HTMLStyleElement) where
+  (HTMLStyleElement a) == (HTMLStyleElement b) = js_eq a b
+
+instance PToJSVal HTMLStyleElement where
+  pToJSVal = unHTMLStyleElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal HTMLStyleElement where
+  pFromJSVal = HTMLStyleElement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal HTMLStyleElement where
+  toJSVal = return . unHTMLStyleElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal HTMLStyleElement where
+  fromJSVal = return . fmap HTMLStyleElement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsHTMLElement HTMLStyleElement
+instance IsElement HTMLStyleElement
+instance IsNode HTMLStyleElement
+instance IsEventTarget HTMLStyleElement
+instance IsGObject HTMLStyleElement where
+  typeGType _ = gTypeHTMLStyleElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"HTMLStyleElement\"]" gTypeHTMLStyleElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.HTMLTableCaptionElement".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.HTMLElement"
+--     * "GHCJS.DOM.Element"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/HTMLTableCaptionElement Mozilla HTMLTableCaptionElement documentation>
+newtype HTMLTableCaptionElement = HTMLTableCaptionElement { unHTMLTableCaptionElement :: JSVal }
+
+instance Eq (HTMLTableCaptionElement) where
+  (HTMLTableCaptionElement a) == (HTMLTableCaptionElement b) = js_eq a b
+
+instance PToJSVal HTMLTableCaptionElement where
+  pToJSVal = unHTMLTableCaptionElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal HTMLTableCaptionElement where
+  pFromJSVal = HTMLTableCaptionElement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal HTMLTableCaptionElement where
+  toJSVal = return . unHTMLTableCaptionElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal HTMLTableCaptionElement where
+  fromJSVal = return . fmap HTMLTableCaptionElement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsHTMLElement HTMLTableCaptionElement
+instance IsElement HTMLTableCaptionElement
+instance IsNode HTMLTableCaptionElement
+instance IsEventTarget HTMLTableCaptionElement
+instance IsGObject HTMLTableCaptionElement where
+  typeGType _ = gTypeHTMLTableCaptionElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"HTMLTableCaptionElement\"]" gTypeHTMLTableCaptionElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.HTMLTableCellElement".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.HTMLElement"
+--     * "GHCJS.DOM.Element"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/HTMLTableCellElement Mozilla HTMLTableCellElement documentation>
+newtype HTMLTableCellElement = HTMLTableCellElement { unHTMLTableCellElement :: JSVal }
+
+instance Eq (HTMLTableCellElement) where
+  (HTMLTableCellElement a) == (HTMLTableCellElement b) = js_eq a b
+
+instance PToJSVal HTMLTableCellElement where
+  pToJSVal = unHTMLTableCellElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal HTMLTableCellElement where
+  pFromJSVal = HTMLTableCellElement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal HTMLTableCellElement where
+  toJSVal = return . unHTMLTableCellElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal HTMLTableCellElement where
+  fromJSVal = return . fmap HTMLTableCellElement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsHTMLElement HTMLTableCellElement
+instance IsElement HTMLTableCellElement
+instance IsNode HTMLTableCellElement
+instance IsEventTarget HTMLTableCellElement
+instance IsGObject HTMLTableCellElement where
+  typeGType _ = gTypeHTMLTableCellElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"HTMLTableCellElement\"]" gTypeHTMLTableCellElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.HTMLTableColElement".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.HTMLElement"
+--     * "GHCJS.DOM.Element"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/HTMLTableColElement Mozilla HTMLTableColElement documentation>
+newtype HTMLTableColElement = HTMLTableColElement { unHTMLTableColElement :: JSVal }
+
+instance Eq (HTMLTableColElement) where
+  (HTMLTableColElement a) == (HTMLTableColElement b) = js_eq a b
+
+instance PToJSVal HTMLTableColElement where
+  pToJSVal = unHTMLTableColElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal HTMLTableColElement where
+  pFromJSVal = HTMLTableColElement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal HTMLTableColElement where
+  toJSVal = return . unHTMLTableColElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal HTMLTableColElement where
+  fromJSVal = return . fmap HTMLTableColElement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsHTMLElement HTMLTableColElement
+instance IsElement HTMLTableColElement
+instance IsNode HTMLTableColElement
+instance IsEventTarget HTMLTableColElement
+instance IsGObject HTMLTableColElement where
+  typeGType _ = gTypeHTMLTableColElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"HTMLTableColElement\"]" gTypeHTMLTableColElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.HTMLTableElement".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.HTMLElement"
+--     * "GHCJS.DOM.Element"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/HTMLTableElement Mozilla HTMLTableElement documentation>
+newtype HTMLTableElement = HTMLTableElement { unHTMLTableElement :: JSVal }
+
+instance Eq (HTMLTableElement) where
+  (HTMLTableElement a) == (HTMLTableElement b) = js_eq a b
+
+instance PToJSVal HTMLTableElement where
+  pToJSVal = unHTMLTableElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal HTMLTableElement where
+  pFromJSVal = HTMLTableElement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal HTMLTableElement where
+  toJSVal = return . unHTMLTableElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal HTMLTableElement where
+  fromJSVal = return . fmap HTMLTableElement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsHTMLElement HTMLTableElement
+instance IsElement HTMLTableElement
+instance IsNode HTMLTableElement
+instance IsEventTarget HTMLTableElement
+instance IsGObject HTMLTableElement where
+  typeGType _ = gTypeHTMLTableElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"HTMLTableElement\"]" gTypeHTMLTableElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.HTMLTableRowElement".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.HTMLElement"
+--     * "GHCJS.DOM.Element"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/HTMLTableRowElement Mozilla HTMLTableRowElement documentation>
+newtype HTMLTableRowElement = HTMLTableRowElement { unHTMLTableRowElement :: JSVal }
+
+instance Eq (HTMLTableRowElement) where
+  (HTMLTableRowElement a) == (HTMLTableRowElement b) = js_eq a b
+
+instance PToJSVal HTMLTableRowElement where
+  pToJSVal = unHTMLTableRowElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal HTMLTableRowElement where
+  pFromJSVal = HTMLTableRowElement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal HTMLTableRowElement where
+  toJSVal = return . unHTMLTableRowElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal HTMLTableRowElement where
+  fromJSVal = return . fmap HTMLTableRowElement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsHTMLElement HTMLTableRowElement
+instance IsElement HTMLTableRowElement
+instance IsNode HTMLTableRowElement
+instance IsEventTarget HTMLTableRowElement
+instance IsGObject HTMLTableRowElement where
+  typeGType _ = gTypeHTMLTableRowElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"HTMLTableRowElement\"]" gTypeHTMLTableRowElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.HTMLTableSectionElement".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.HTMLElement"
+--     * "GHCJS.DOM.Element"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/HTMLTableSectionElement Mozilla HTMLTableSectionElement documentation>
+newtype HTMLTableSectionElement = HTMLTableSectionElement { unHTMLTableSectionElement :: JSVal }
+
+instance Eq (HTMLTableSectionElement) where
+  (HTMLTableSectionElement a) == (HTMLTableSectionElement b) = js_eq a b
+
+instance PToJSVal HTMLTableSectionElement where
+  pToJSVal = unHTMLTableSectionElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal HTMLTableSectionElement where
+  pFromJSVal = HTMLTableSectionElement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal HTMLTableSectionElement where
+  toJSVal = return . unHTMLTableSectionElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal HTMLTableSectionElement where
+  fromJSVal = return . fmap HTMLTableSectionElement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsHTMLElement HTMLTableSectionElement
+instance IsElement HTMLTableSectionElement
+instance IsNode HTMLTableSectionElement
+instance IsEventTarget HTMLTableSectionElement
+instance IsGObject HTMLTableSectionElement where
+  typeGType _ = gTypeHTMLTableSectionElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"HTMLTableSectionElement\"]" gTypeHTMLTableSectionElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.HTMLTemplateElement".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.HTMLElement"
+--     * "GHCJS.DOM.Element"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/HTMLTemplateElement Mozilla HTMLTemplateElement documentation>
+newtype HTMLTemplateElement = HTMLTemplateElement { unHTMLTemplateElement :: JSVal }
+
+instance Eq (HTMLTemplateElement) where
+  (HTMLTemplateElement a) == (HTMLTemplateElement b) = js_eq a b
+
+instance PToJSVal HTMLTemplateElement where
+  pToJSVal = unHTMLTemplateElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal HTMLTemplateElement where
+  pFromJSVal = HTMLTemplateElement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal HTMLTemplateElement where
+  toJSVal = return . unHTMLTemplateElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal HTMLTemplateElement where
+  fromJSVal = return . fmap HTMLTemplateElement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsHTMLElement HTMLTemplateElement
+instance IsElement HTMLTemplateElement
+instance IsNode HTMLTemplateElement
+instance IsEventTarget HTMLTemplateElement
+instance IsGObject HTMLTemplateElement where
+  typeGType _ = gTypeHTMLTemplateElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"HTMLTemplateElement\"]" gTypeHTMLTemplateElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.HTMLTextAreaElement".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.HTMLElement"
+--     * "GHCJS.DOM.Element"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/HTMLTextAreaElement Mozilla HTMLTextAreaElement documentation>
+newtype HTMLTextAreaElement = HTMLTextAreaElement { unHTMLTextAreaElement :: JSVal }
+
+instance Eq (HTMLTextAreaElement) where
+  (HTMLTextAreaElement a) == (HTMLTextAreaElement b) = js_eq a b
+
+instance PToJSVal HTMLTextAreaElement where
+  pToJSVal = unHTMLTextAreaElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal HTMLTextAreaElement where
+  pFromJSVal = HTMLTextAreaElement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal HTMLTextAreaElement where
+  toJSVal = return . unHTMLTextAreaElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal HTMLTextAreaElement where
+  fromJSVal = return . fmap HTMLTextAreaElement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsHTMLElement HTMLTextAreaElement
+instance IsElement HTMLTextAreaElement
+instance IsNode HTMLTextAreaElement
+instance IsEventTarget HTMLTextAreaElement
+instance IsGObject HTMLTextAreaElement where
+  typeGType _ = gTypeHTMLTextAreaElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"HTMLTextAreaElement\"]" gTypeHTMLTextAreaElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.HTMLTitleElement".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.HTMLElement"
+--     * "GHCJS.DOM.Element"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/HTMLTitleElement Mozilla HTMLTitleElement documentation>
+newtype HTMLTitleElement = HTMLTitleElement { unHTMLTitleElement :: JSVal }
+
+instance Eq (HTMLTitleElement) where
+  (HTMLTitleElement a) == (HTMLTitleElement b) = js_eq a b
+
+instance PToJSVal HTMLTitleElement where
+  pToJSVal = unHTMLTitleElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal HTMLTitleElement where
+  pFromJSVal = HTMLTitleElement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal HTMLTitleElement where
+  toJSVal = return . unHTMLTitleElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal HTMLTitleElement where
+  fromJSVal = return . fmap HTMLTitleElement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsHTMLElement HTMLTitleElement
+instance IsElement HTMLTitleElement
+instance IsNode HTMLTitleElement
+instance IsEventTarget HTMLTitleElement
+instance IsGObject HTMLTitleElement where
+  typeGType _ = gTypeHTMLTitleElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"HTMLTitleElement\"]" gTypeHTMLTitleElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.HTMLTrackElement".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.HTMLElement"
+--     * "GHCJS.DOM.Element"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/HTMLTrackElement Mozilla HTMLTrackElement documentation>
+newtype HTMLTrackElement = HTMLTrackElement { unHTMLTrackElement :: JSVal }
+
+instance Eq (HTMLTrackElement) where
+  (HTMLTrackElement a) == (HTMLTrackElement b) = js_eq a b
+
+instance PToJSVal HTMLTrackElement where
+  pToJSVal = unHTMLTrackElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal HTMLTrackElement where
+  pFromJSVal = HTMLTrackElement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal HTMLTrackElement where
+  toJSVal = return . unHTMLTrackElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal HTMLTrackElement where
+  fromJSVal = return . fmap HTMLTrackElement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsHTMLElement HTMLTrackElement
+instance IsElement HTMLTrackElement
+instance IsNode HTMLTrackElement
+instance IsEventTarget HTMLTrackElement
+instance IsGObject HTMLTrackElement where
+  typeGType _ = gTypeHTMLTrackElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"HTMLTrackElement\"]" gTypeHTMLTrackElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.HTMLUListElement".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.HTMLElement"
+--     * "GHCJS.DOM.Element"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/HTMLUListElement Mozilla HTMLUListElement documentation>
+newtype HTMLUListElement = HTMLUListElement { unHTMLUListElement :: JSVal }
+
+instance Eq (HTMLUListElement) where
+  (HTMLUListElement a) == (HTMLUListElement b) = js_eq a b
+
+instance PToJSVal HTMLUListElement where
+  pToJSVal = unHTMLUListElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal HTMLUListElement where
+  pFromJSVal = HTMLUListElement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal HTMLUListElement where
+  toJSVal = return . unHTMLUListElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal HTMLUListElement where
+  fromJSVal = return . fmap HTMLUListElement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsHTMLElement HTMLUListElement
+instance IsElement HTMLUListElement
+instance IsNode HTMLUListElement
+instance IsEventTarget HTMLUListElement
+instance IsGObject HTMLUListElement where
+  typeGType _ = gTypeHTMLUListElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"HTMLUListElement\"]" gTypeHTMLUListElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.HTMLUnknownElement".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.HTMLElement"
+--     * "GHCJS.DOM.Element"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/HTMLUnknownElement Mozilla HTMLUnknownElement documentation>
+newtype HTMLUnknownElement = HTMLUnknownElement { unHTMLUnknownElement :: JSVal }
+
+instance Eq (HTMLUnknownElement) where
+  (HTMLUnknownElement a) == (HTMLUnknownElement b) = js_eq a b
+
+instance PToJSVal HTMLUnknownElement where
+  pToJSVal = unHTMLUnknownElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal HTMLUnknownElement where
+  pFromJSVal = HTMLUnknownElement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal HTMLUnknownElement where
+  toJSVal = return . unHTMLUnknownElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal HTMLUnknownElement where
+  fromJSVal = return . fmap HTMLUnknownElement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsHTMLElement HTMLUnknownElement
+instance IsElement HTMLUnknownElement
+instance IsNode HTMLUnknownElement
+instance IsEventTarget HTMLUnknownElement
+instance IsGObject HTMLUnknownElement where
+  typeGType _ = gTypeHTMLUnknownElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"HTMLUnknownElement\"]" gTypeHTMLUnknownElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.HTMLVideoElement".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.HTMLMediaElement"
+--     * "GHCJS.DOM.HTMLElement"
+--     * "GHCJS.DOM.Element"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/HTMLVideoElement Mozilla HTMLVideoElement documentation>
+newtype HTMLVideoElement = HTMLVideoElement { unHTMLVideoElement :: JSVal }
+
+instance Eq (HTMLVideoElement) where
+  (HTMLVideoElement a) == (HTMLVideoElement b) = js_eq a b
+
+instance PToJSVal HTMLVideoElement where
+  pToJSVal = unHTMLVideoElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal HTMLVideoElement where
+  pFromJSVal = HTMLVideoElement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal HTMLVideoElement where
+  toJSVal = return . unHTMLVideoElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal HTMLVideoElement where
+  fromJSVal = return . fmap HTMLVideoElement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsHTMLMediaElement HTMLVideoElement
+instance IsHTMLElement HTMLVideoElement
+instance IsElement HTMLVideoElement
+instance IsNode HTMLVideoElement
+instance IsEventTarget HTMLVideoElement
+instance IsGObject HTMLVideoElement where
+  typeGType _ = gTypeHTMLVideoElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"HTMLVideoElement\"]" gTypeHTMLVideoElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.HashChangeEvent".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.Event"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/HashChangeEvent Mozilla HashChangeEvent documentation>
+newtype HashChangeEvent = HashChangeEvent { unHashChangeEvent :: JSVal }
+
+instance Eq (HashChangeEvent) where
+  (HashChangeEvent a) == (HashChangeEvent b) = js_eq a b
+
+instance PToJSVal HashChangeEvent where
+  pToJSVal = unHashChangeEvent
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal HashChangeEvent where
+  pFromJSVal = HashChangeEvent
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal HashChangeEvent where
+  toJSVal = return . unHashChangeEvent
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal HashChangeEvent where
+  fromJSVal = return . fmap HashChangeEvent . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsEvent HashChangeEvent
+instance IsGObject HashChangeEvent where
+  typeGType _ = gTypeHashChangeEvent
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"HashChangeEvent\"]" gTypeHashChangeEvent :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.History".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/History Mozilla History documentation>
+newtype History = History { unHistory :: JSVal }
+
+instance Eq (History) where
+  (History a) == (History b) = js_eq a b
+
+instance PToJSVal History where
+  pToJSVal = unHistory
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal History where
+  pFromJSVal = History
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal History where
+  toJSVal = return . unHistory
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal History where
+  fromJSVal = return . fmap History . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject History where
+  typeGType _ = gTypeHistory
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"History\"]" gTypeHistory :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.IDBAny".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/IDBAny Mozilla IDBAny documentation>
+newtype IDBAny = IDBAny { unIDBAny :: JSVal }
+
+instance Eq (IDBAny) where
+  (IDBAny a) == (IDBAny b) = js_eq a b
+
+instance PToJSVal IDBAny where
+  pToJSVal = unIDBAny
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal IDBAny where
+  pFromJSVal = IDBAny
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal IDBAny where
+  toJSVal = return . unIDBAny
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal IDBAny where
+  fromJSVal = return . fmap IDBAny . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject IDBAny where
+  typeGType _ = gTypeIDBAny
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"IDBAny\"]" gTypeIDBAny :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.IDBCursor".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/IDBCursor Mozilla IDBCursor documentation>
+newtype IDBCursor = IDBCursor { unIDBCursor :: JSVal }
+
+instance Eq (IDBCursor) where
+  (IDBCursor a) == (IDBCursor b) = js_eq a b
+
+instance PToJSVal IDBCursor where
+  pToJSVal = unIDBCursor
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal IDBCursor where
+  pFromJSVal = IDBCursor
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal IDBCursor where
+  toJSVal = return . unIDBCursor
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal IDBCursor where
+  fromJSVal = return . fmap IDBCursor . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+class IsGObject o => IsIDBCursor o
+toIDBCursor :: IsIDBCursor o => o -> IDBCursor
+toIDBCursor = IDBCursor . coerce
+
+instance IsIDBCursor IDBCursor
+instance IsGObject IDBCursor where
+  typeGType _ = gTypeIDBCursor
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"IDBCursor\"]" gTypeIDBCursor :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.IDBCursorWithValue".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.IDBCursor"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/IDBCursorWithValue Mozilla IDBCursorWithValue documentation>
+newtype IDBCursorWithValue = IDBCursorWithValue { unIDBCursorWithValue :: JSVal }
+
+instance Eq (IDBCursorWithValue) where
+  (IDBCursorWithValue a) == (IDBCursorWithValue b) = js_eq a b
+
+instance PToJSVal IDBCursorWithValue where
+  pToJSVal = unIDBCursorWithValue
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal IDBCursorWithValue where
+  pFromJSVal = IDBCursorWithValue
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal IDBCursorWithValue where
+  toJSVal = return . unIDBCursorWithValue
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal IDBCursorWithValue where
+  fromJSVal = return . fmap IDBCursorWithValue . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsIDBCursor IDBCursorWithValue
+instance IsGObject IDBCursorWithValue where
+  typeGType _ = gTypeIDBCursorWithValue
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"IDBCursorWithValue\"]" gTypeIDBCursorWithValue :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.IDBDatabase".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/IDBDatabase Mozilla IDBDatabase documentation>
+newtype IDBDatabase = IDBDatabase { unIDBDatabase :: JSVal }
+
+instance Eq (IDBDatabase) where
+  (IDBDatabase a) == (IDBDatabase b) = js_eq a b
+
+instance PToJSVal IDBDatabase where
+  pToJSVal = unIDBDatabase
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal IDBDatabase where
+  pFromJSVal = IDBDatabase
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal IDBDatabase where
+  toJSVal = return . unIDBDatabase
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal IDBDatabase where
+  fromJSVal = return . fmap IDBDatabase . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsEventTarget IDBDatabase
+instance IsGObject IDBDatabase where
+  typeGType _ = gTypeIDBDatabase
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"IDBDatabase\"]" gTypeIDBDatabase :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.IDBFactory".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/IDBFactory Mozilla IDBFactory documentation>
+newtype IDBFactory = IDBFactory { unIDBFactory :: JSVal }
+
+instance Eq (IDBFactory) where
+  (IDBFactory a) == (IDBFactory b) = js_eq a b
+
+instance PToJSVal IDBFactory where
+  pToJSVal = unIDBFactory
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal IDBFactory where
+  pFromJSVal = IDBFactory
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal IDBFactory where
+  toJSVal = return . unIDBFactory
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal IDBFactory where
+  fromJSVal = return . fmap IDBFactory . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject IDBFactory where
+  typeGType _ = gTypeIDBFactory
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"IDBFactory\"]" gTypeIDBFactory :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.IDBIndex".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/IDBIndex Mozilla IDBIndex documentation>
+newtype IDBIndex = IDBIndex { unIDBIndex :: JSVal }
+
+instance Eq (IDBIndex) where
+  (IDBIndex a) == (IDBIndex b) = js_eq a b
+
+instance PToJSVal IDBIndex where
+  pToJSVal = unIDBIndex
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal IDBIndex where
+  pFromJSVal = IDBIndex
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal IDBIndex where
+  toJSVal = return . unIDBIndex
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal IDBIndex where
+  fromJSVal = return . fmap IDBIndex . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject IDBIndex where
+  typeGType _ = gTypeIDBIndex
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"IDBIndex\"]" gTypeIDBIndex :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.IDBKeyRange".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/IDBKeyRange Mozilla IDBKeyRange documentation>
+newtype IDBKeyRange = IDBKeyRange { unIDBKeyRange :: JSVal }
+
+instance Eq (IDBKeyRange) where
+  (IDBKeyRange a) == (IDBKeyRange b) = js_eq a b
+
+instance PToJSVal IDBKeyRange where
+  pToJSVal = unIDBKeyRange
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal IDBKeyRange where
+  pFromJSVal = IDBKeyRange
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal IDBKeyRange where
+  toJSVal = return . unIDBKeyRange
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal IDBKeyRange where
+  fromJSVal = return . fmap IDBKeyRange . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject IDBKeyRange where
+  typeGType _ = gTypeIDBKeyRange
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"IDBKeyRange\"]" gTypeIDBKeyRange :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.IDBObjectStore".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/IDBObjectStore Mozilla IDBObjectStore documentation>
+newtype IDBObjectStore = IDBObjectStore { unIDBObjectStore :: JSVal }
+
+instance Eq (IDBObjectStore) where
+  (IDBObjectStore a) == (IDBObjectStore b) = js_eq a b
+
+instance PToJSVal IDBObjectStore where
+  pToJSVal = unIDBObjectStore
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal IDBObjectStore where
+  pFromJSVal = IDBObjectStore
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal IDBObjectStore where
+  toJSVal = return . unIDBObjectStore
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal IDBObjectStore where
+  fromJSVal = return . fmap IDBObjectStore . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject IDBObjectStore where
+  typeGType _ = gTypeIDBObjectStore
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"IDBObjectStore\"]" gTypeIDBObjectStore :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.IDBOpenDBRequest".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.IDBRequest"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/IDBOpenDBRequest Mozilla IDBOpenDBRequest documentation>
+newtype IDBOpenDBRequest = IDBOpenDBRequest { unIDBOpenDBRequest :: JSVal }
+
+instance Eq (IDBOpenDBRequest) where
+  (IDBOpenDBRequest a) == (IDBOpenDBRequest b) = js_eq a b
+
+instance PToJSVal IDBOpenDBRequest where
+  pToJSVal = unIDBOpenDBRequest
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal IDBOpenDBRequest where
+  pFromJSVal = IDBOpenDBRequest
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal IDBOpenDBRequest where
+  toJSVal = return . unIDBOpenDBRequest
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal IDBOpenDBRequest where
+  fromJSVal = return . fmap IDBOpenDBRequest . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsIDBRequest IDBOpenDBRequest
+instance IsEventTarget IDBOpenDBRequest
+instance IsGObject IDBOpenDBRequest where
+  typeGType _ = gTypeIDBOpenDBRequest
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"IDBOpenDBRequest\"]" gTypeIDBOpenDBRequest :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.IDBRequest".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/IDBRequest Mozilla IDBRequest documentation>
+newtype IDBRequest = IDBRequest { unIDBRequest :: JSVal }
+
+instance Eq (IDBRequest) where
+  (IDBRequest a) == (IDBRequest b) = js_eq a b
+
+instance PToJSVal IDBRequest where
+  pToJSVal = unIDBRequest
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal IDBRequest where
+  pFromJSVal = IDBRequest
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal IDBRequest where
+  toJSVal = return . unIDBRequest
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal IDBRequest where
+  fromJSVal = return . fmap IDBRequest . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+class IsEventTarget o => IsIDBRequest o
+toIDBRequest :: IsIDBRequest o => o -> IDBRequest
+toIDBRequest = IDBRequest . coerce
+
+instance IsIDBRequest IDBRequest
+instance IsEventTarget IDBRequest
+instance IsGObject IDBRequest where
+  typeGType _ = gTypeIDBRequest
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"IDBRequest\"]" gTypeIDBRequest :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.IDBTransaction".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/IDBTransaction Mozilla IDBTransaction documentation>
+newtype IDBTransaction = IDBTransaction { unIDBTransaction :: JSVal }
+
+instance Eq (IDBTransaction) where
+  (IDBTransaction a) == (IDBTransaction b) = js_eq a b
+
+instance PToJSVal IDBTransaction where
+  pToJSVal = unIDBTransaction
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal IDBTransaction where
+  pFromJSVal = IDBTransaction
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal IDBTransaction where
+  toJSVal = return . unIDBTransaction
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal IDBTransaction where
+  fromJSVal = return . fmap IDBTransaction . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsEventTarget IDBTransaction
+instance IsGObject IDBTransaction where
+  typeGType _ = gTypeIDBTransaction
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"IDBTransaction\"]" gTypeIDBTransaction :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.IDBVersionChangeEvent".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.Event"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/IDBVersionChangeEvent Mozilla IDBVersionChangeEvent documentation>
+newtype IDBVersionChangeEvent = IDBVersionChangeEvent { unIDBVersionChangeEvent :: JSVal }
+
+instance Eq (IDBVersionChangeEvent) where
+  (IDBVersionChangeEvent a) == (IDBVersionChangeEvent b) = js_eq a b
+
+instance PToJSVal IDBVersionChangeEvent where
+  pToJSVal = unIDBVersionChangeEvent
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal IDBVersionChangeEvent where
+  pFromJSVal = IDBVersionChangeEvent
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal IDBVersionChangeEvent where
+  toJSVal = return . unIDBVersionChangeEvent
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal IDBVersionChangeEvent where
+  fromJSVal = return . fmap IDBVersionChangeEvent . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsEvent IDBVersionChangeEvent
+instance IsGObject IDBVersionChangeEvent where
+  typeGType _ = gTypeIDBVersionChangeEvent
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"IDBVersionChangeEvent\"]" gTypeIDBVersionChangeEvent :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.ImageData".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/ImageData Mozilla ImageData documentation>
+newtype ImageData = ImageData { unImageData :: JSVal }
+
+instance Eq (ImageData) where
+  (ImageData a) == (ImageData b) = js_eq a b
+
+instance PToJSVal ImageData where
+  pToJSVal = unImageData
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal ImageData where
+  pFromJSVal = ImageData
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal ImageData where
+  toJSVal = return . unImageData
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal ImageData where
+  fromJSVal = return . fmap ImageData . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject ImageData where
+  typeGType _ = gTypeImageData
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"ImageData\"]" gTypeImageData :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.InspectorFrontendHost".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/InspectorFrontendHost Mozilla InspectorFrontendHost documentation>
+newtype InspectorFrontendHost = InspectorFrontendHost { unInspectorFrontendHost :: JSVal }
+
+instance Eq (InspectorFrontendHost) where
+  (InspectorFrontendHost a) == (InspectorFrontendHost b) = js_eq a b
+
+instance PToJSVal InspectorFrontendHost where
+  pToJSVal = unInspectorFrontendHost
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal InspectorFrontendHost where
+  pFromJSVal = InspectorFrontendHost
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal InspectorFrontendHost where
+  toJSVal = return . unInspectorFrontendHost
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal InspectorFrontendHost where
+  fromJSVal = return . fmap InspectorFrontendHost . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject InspectorFrontendHost where
+  typeGType _ = gTypeInspectorFrontendHost
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"InspectorFrontendHost\"]" gTypeInspectorFrontendHost :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.InternalSettings".
+-- Base interface functions are in:
+--
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/InternalSettings Mozilla InternalSettings documentation>
+newtype InternalSettings = InternalSettings { unInternalSettings :: JSVal }
+
+instance Eq (InternalSettings) where
+  (InternalSettings a) == (InternalSettings b) = js_eq a b
+
+instance PToJSVal InternalSettings where
+  pToJSVal = unInternalSettings
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal InternalSettings where
+  pFromJSVal = InternalSettings
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal InternalSettings where
+  toJSVal = return . unInternalSettings
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal InternalSettings where
+  fromJSVal = return . fmap InternalSettings . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject InternalSettings where
+  typeGType _ = gTypeInternalSettings
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"InternalSettings\"]" gTypeInternalSettings :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.Internals".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/Internals Mozilla Internals documentation>
+newtype Internals = Internals { unInternals :: JSVal }
+
+instance Eq (Internals) where
+  (Internals a) == (Internals b) = js_eq a b
+
+instance PToJSVal Internals where
+  pToJSVal = unInternals
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal Internals where
+  pFromJSVal = Internals
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal Internals where
+  toJSVal = return . unInternals
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal Internals where
+  fromJSVal = return . fmap Internals . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject Internals where
+  typeGType _ = gTypeInternals
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"Internals\"]" gTypeInternals :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.KeyboardEvent".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.UIEvent"
+--     * "GHCJS.DOM.Event"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent Mozilla KeyboardEvent documentation>
+newtype KeyboardEvent = KeyboardEvent { unKeyboardEvent :: JSVal }
+
+instance Eq (KeyboardEvent) where
+  (KeyboardEvent a) == (KeyboardEvent b) = js_eq a b
+
+instance PToJSVal KeyboardEvent where
+  pToJSVal = unKeyboardEvent
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal KeyboardEvent where
+  pFromJSVal = KeyboardEvent
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal KeyboardEvent where
+  toJSVal = return . unKeyboardEvent
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal KeyboardEvent where
+  fromJSVal = return . fmap KeyboardEvent . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsUIEvent KeyboardEvent
+instance IsEvent KeyboardEvent
+instance IsGObject KeyboardEvent where
+  typeGType _ = gTypeKeyboardEvent
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"KeyboardEvent\"]" gTypeKeyboardEvent :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.Location".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/Location Mozilla Location documentation>
+newtype Location = Location { unLocation :: JSVal }
+
+instance Eq (Location) where
+  (Location a) == (Location b) = js_eq a b
+
+instance PToJSVal Location where
+  pToJSVal = unLocation
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal Location where
+  pFromJSVal = Location
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal Location where
+  toJSVal = return . unLocation
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal Location where
+  fromJSVal = return . fmap Location . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject Location where
+  typeGType _ = gTypeLocation
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"Location\"]" gTypeLocation :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.MallocStatistics".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/MallocStatistics Mozilla MallocStatistics documentation>
+newtype MallocStatistics = MallocStatistics { unMallocStatistics :: JSVal }
+
+instance Eq (MallocStatistics) where
+  (MallocStatistics a) == (MallocStatistics b) = js_eq a b
+
+instance PToJSVal MallocStatistics where
+  pToJSVal = unMallocStatistics
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal MallocStatistics where
+  pFromJSVal = MallocStatistics
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal MallocStatistics where
+  toJSVal = return . unMallocStatistics
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal MallocStatistics where
+  fromJSVal = return . fmap MallocStatistics . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject MallocStatistics where
+  typeGType _ = gTypeMallocStatistics
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"MallocStatistics\"]" gTypeMallocStatistics :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.MediaController".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/MediaController Mozilla MediaController documentation>
+newtype MediaController = MediaController { unMediaController :: JSVal }
+
+instance Eq (MediaController) where
+  (MediaController a) == (MediaController b) = js_eq a b
+
+instance PToJSVal MediaController where
+  pToJSVal = unMediaController
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal MediaController where
+  pFromJSVal = MediaController
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal MediaController where
+  toJSVal = return . unMediaController
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal MediaController where
+  fromJSVal = return . fmap MediaController . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsEventTarget MediaController
+instance IsGObject MediaController where
+  typeGType _ = gTypeMediaController
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"MediaController\"]" gTypeMediaController :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.MediaControlsHost".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/MediaControlsHost Mozilla MediaControlsHost documentation>
+newtype MediaControlsHost = MediaControlsHost { unMediaControlsHost :: JSVal }
+
+instance Eq (MediaControlsHost) where
+  (MediaControlsHost a) == (MediaControlsHost b) = js_eq a b
+
+instance PToJSVal MediaControlsHost where
+  pToJSVal = unMediaControlsHost
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal MediaControlsHost where
+  pFromJSVal = MediaControlsHost
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal MediaControlsHost where
+  toJSVal = return . unMediaControlsHost
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal MediaControlsHost where
+  fromJSVal = return . fmap MediaControlsHost . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject MediaControlsHost where
+  typeGType _ = gTypeMediaControlsHost
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"MediaControlsHost\"]" gTypeMediaControlsHost :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.MediaElementAudioSourceNode".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.AudioNode"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/MediaElementAudioSourceNode Mozilla MediaElementAudioSourceNode documentation>
+newtype MediaElementAudioSourceNode = MediaElementAudioSourceNode { unMediaElementAudioSourceNode :: JSVal }
+
+instance Eq (MediaElementAudioSourceNode) where
+  (MediaElementAudioSourceNode a) == (MediaElementAudioSourceNode b) = js_eq a b
+
+instance PToJSVal MediaElementAudioSourceNode where
+  pToJSVal = unMediaElementAudioSourceNode
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal MediaElementAudioSourceNode where
+  pFromJSVal = MediaElementAudioSourceNode
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal MediaElementAudioSourceNode where
+  toJSVal = return . unMediaElementAudioSourceNode
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal MediaElementAudioSourceNode where
+  fromJSVal = return . fmap MediaElementAudioSourceNode . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsAudioNode MediaElementAudioSourceNode
+instance IsEventTarget MediaElementAudioSourceNode
+instance IsGObject MediaElementAudioSourceNode where
+  typeGType _ = gTypeMediaElementAudioSourceNode
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"MediaElementAudioSourceNode\"]" gTypeMediaElementAudioSourceNode :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.MediaError".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/MediaError Mozilla MediaError documentation>
+newtype MediaError = MediaError { unMediaError :: JSVal }
+
+instance Eq (MediaError) where
+  (MediaError a) == (MediaError b) = js_eq a b
+
+instance PToJSVal MediaError where
+  pToJSVal = unMediaError
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal MediaError where
+  pFromJSVal = MediaError
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal MediaError where
+  toJSVal = return . unMediaError
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal MediaError where
+  fromJSVal = return . fmap MediaError . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject MediaError where
+  typeGType _ = gTypeMediaError
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"MediaError\"]" gTypeMediaError :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.MediaKeyError".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/WebKitMediaKeyError Mozilla WebKitMediaKeyError documentation>
+newtype MediaKeyError = MediaKeyError { unMediaKeyError :: JSVal }
+
+instance Eq (MediaKeyError) where
+  (MediaKeyError a) == (MediaKeyError b) = js_eq a b
+
+instance PToJSVal MediaKeyError where
+  pToJSVal = unMediaKeyError
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal MediaKeyError where
+  pFromJSVal = MediaKeyError
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal MediaKeyError where
+  toJSVal = return . unMediaKeyError
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal MediaKeyError where
+  fromJSVal = return . fmap MediaKeyError . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject MediaKeyError where
+  typeGType _ = gTypeMediaKeyError
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"WebKitMediaKeyError\"]" gTypeMediaKeyError :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.MediaKeyEvent".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.Event"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/MediaKeyEvent Mozilla MediaKeyEvent documentation>
+newtype MediaKeyEvent = MediaKeyEvent { unMediaKeyEvent :: JSVal }
+
+instance Eq (MediaKeyEvent) where
+  (MediaKeyEvent a) == (MediaKeyEvent b) = js_eq a b
+
+instance PToJSVal MediaKeyEvent where
+  pToJSVal = unMediaKeyEvent
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal MediaKeyEvent where
+  pFromJSVal = MediaKeyEvent
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal MediaKeyEvent where
+  toJSVal = return . unMediaKeyEvent
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal MediaKeyEvent where
+  fromJSVal = return . fmap MediaKeyEvent . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsEvent MediaKeyEvent
+instance IsGObject MediaKeyEvent where
+  typeGType _ = gTypeMediaKeyEvent
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"MediaKeyEvent\"]" gTypeMediaKeyEvent :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.MediaKeyMessageEvent".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.Event"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/WebKitMediaKeyMessageEvent Mozilla WebKitMediaKeyMessageEvent documentation>
+newtype MediaKeyMessageEvent = MediaKeyMessageEvent { unMediaKeyMessageEvent :: JSVal }
+
+instance Eq (MediaKeyMessageEvent) where
+  (MediaKeyMessageEvent a) == (MediaKeyMessageEvent b) = js_eq a b
+
+instance PToJSVal MediaKeyMessageEvent where
+  pToJSVal = unMediaKeyMessageEvent
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal MediaKeyMessageEvent where
+  pFromJSVal = MediaKeyMessageEvent
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal MediaKeyMessageEvent where
+  toJSVal = return . unMediaKeyMessageEvent
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal MediaKeyMessageEvent where
+  fromJSVal = return . fmap MediaKeyMessageEvent . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsEvent MediaKeyMessageEvent
+instance IsGObject MediaKeyMessageEvent where
+  typeGType _ = gTypeMediaKeyMessageEvent
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"WebKitMediaKeyMessageEvent\"]" gTypeMediaKeyMessageEvent :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.MediaKeyNeededEvent".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.Event"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/MediaKeyNeededEvent Mozilla MediaKeyNeededEvent documentation>
+newtype MediaKeyNeededEvent = MediaKeyNeededEvent { unMediaKeyNeededEvent :: JSVal }
+
+instance Eq (MediaKeyNeededEvent) where
+  (MediaKeyNeededEvent a) == (MediaKeyNeededEvent b) = js_eq a b
+
+instance PToJSVal MediaKeyNeededEvent where
+  pToJSVal = unMediaKeyNeededEvent
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal MediaKeyNeededEvent where
+  pFromJSVal = MediaKeyNeededEvent
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal MediaKeyNeededEvent where
+  toJSVal = return . unMediaKeyNeededEvent
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal MediaKeyNeededEvent where
+  fromJSVal = return . fmap MediaKeyNeededEvent . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsEvent MediaKeyNeededEvent
+instance IsGObject MediaKeyNeededEvent where
+  typeGType _ = gTypeMediaKeyNeededEvent
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"MediaKeyNeededEvent\"]" gTypeMediaKeyNeededEvent :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.MediaKeySession".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/WebKitMediaKeySession Mozilla WebKitMediaKeySession documentation>
+newtype MediaKeySession = MediaKeySession { unMediaKeySession :: JSVal }
+
+instance Eq (MediaKeySession) where
+  (MediaKeySession a) == (MediaKeySession b) = js_eq a b
+
+instance PToJSVal MediaKeySession where
+  pToJSVal = unMediaKeySession
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal MediaKeySession where
+  pFromJSVal = MediaKeySession
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal MediaKeySession where
+  toJSVal = return . unMediaKeySession
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal MediaKeySession where
+  fromJSVal = return . fmap MediaKeySession . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsEventTarget MediaKeySession
+instance IsGObject MediaKeySession where
+  typeGType _ = gTypeMediaKeySession
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"WebKitMediaKeySession\"]" gTypeMediaKeySession :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.MediaKeys".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/WebKitMediaKeys Mozilla WebKitMediaKeys documentation>
+newtype MediaKeys = MediaKeys { unMediaKeys :: JSVal }
+
+instance Eq (MediaKeys) where
+  (MediaKeys a) == (MediaKeys b) = js_eq a b
+
+instance PToJSVal MediaKeys where
+  pToJSVal = unMediaKeys
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal MediaKeys where
+  pFromJSVal = MediaKeys
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal MediaKeys where
+  toJSVal = return . unMediaKeys
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal MediaKeys where
+  fromJSVal = return . fmap MediaKeys . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject MediaKeys where
+  typeGType _ = gTypeMediaKeys
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"WebKitMediaKeys\"]" gTypeMediaKeys :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.MediaList".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/MediaList Mozilla MediaList documentation>
+newtype MediaList = MediaList { unMediaList :: JSVal }
+
+instance Eq (MediaList) where
+  (MediaList a) == (MediaList b) = js_eq a b
+
+instance PToJSVal MediaList where
+  pToJSVal = unMediaList
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal MediaList where
+  pFromJSVal = MediaList
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal MediaList where
+  toJSVal = return . unMediaList
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal MediaList where
+  fromJSVal = return . fmap MediaList . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject MediaList where
+  typeGType _ = gTypeMediaList
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"MediaList\"]" gTypeMediaList :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.MediaQueryList".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/MediaQueryList Mozilla MediaQueryList documentation>
+newtype MediaQueryList = MediaQueryList { unMediaQueryList :: JSVal }
+
+instance Eq (MediaQueryList) where
+  (MediaQueryList a) == (MediaQueryList b) = js_eq a b
+
+instance PToJSVal MediaQueryList where
+  pToJSVal = unMediaQueryList
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal MediaQueryList where
+  pFromJSVal = MediaQueryList
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal MediaQueryList where
+  toJSVal = return . unMediaQueryList
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal MediaQueryList where
+  fromJSVal = return . fmap MediaQueryList . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject MediaQueryList where
+  typeGType _ = gTypeMediaQueryList
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"MediaQueryList\"]" gTypeMediaQueryList :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.MediaSource".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/MediaSource Mozilla MediaSource documentation>
+newtype MediaSource = MediaSource { unMediaSource :: JSVal }
+
+instance Eq (MediaSource) where
+  (MediaSource a) == (MediaSource b) = js_eq a b
+
+instance PToJSVal MediaSource where
+  pToJSVal = unMediaSource
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal MediaSource where
+  pFromJSVal = MediaSource
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal MediaSource where
+  toJSVal = return . unMediaSource
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal MediaSource where
+  fromJSVal = return . fmap MediaSource . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsEventTarget MediaSource
+instance IsGObject MediaSource where
+  typeGType _ = gTypeMediaSource
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"MediaSource\"]" gTypeMediaSource :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.MediaSourceStates".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/MediaSourceStates Mozilla MediaSourceStates documentation>
+newtype MediaSourceStates = MediaSourceStates { unMediaSourceStates :: JSVal }
+
+instance Eq (MediaSourceStates) where
+  (MediaSourceStates a) == (MediaSourceStates b) = js_eq a b
+
+instance PToJSVal MediaSourceStates where
+  pToJSVal = unMediaSourceStates
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal MediaSourceStates where
+  pFromJSVal = MediaSourceStates
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal MediaSourceStates where
+  toJSVal = return . unMediaSourceStates
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal MediaSourceStates where
+  fromJSVal = return . fmap MediaSourceStates . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject MediaSourceStates where
+  typeGType _ = gTypeMediaSourceStates
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"MediaSourceStates\"]" gTypeMediaSourceStates :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.MediaStream".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/webkitMediaStream Mozilla webkitMediaStream documentation>
+newtype MediaStream = MediaStream { unMediaStream :: JSVal }
+
+instance Eq (MediaStream) where
+  (MediaStream a) == (MediaStream b) = js_eq a b
+
+instance PToJSVal MediaStream where
+  pToJSVal = unMediaStream
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal MediaStream where
+  pFromJSVal = MediaStream
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal MediaStream where
+  toJSVal = return . unMediaStream
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal MediaStream where
+  fromJSVal = return . fmap MediaStream . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsEventTarget MediaStream
+instance IsGObject MediaStream where
+  typeGType _ = gTypeMediaStream
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"webkitMediaStream\"]" gTypeMediaStream :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.MediaStreamAudioDestinationNode".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.AudioNode"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/MediaStreamAudioDestinationNode Mozilla MediaStreamAudioDestinationNode documentation>
+newtype MediaStreamAudioDestinationNode = MediaStreamAudioDestinationNode { unMediaStreamAudioDestinationNode :: JSVal }
+
+instance Eq (MediaStreamAudioDestinationNode) where
+  (MediaStreamAudioDestinationNode a) == (MediaStreamAudioDestinationNode b) = js_eq a b
+
+instance PToJSVal MediaStreamAudioDestinationNode where
+  pToJSVal = unMediaStreamAudioDestinationNode
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal MediaStreamAudioDestinationNode where
+  pFromJSVal = MediaStreamAudioDestinationNode
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal MediaStreamAudioDestinationNode where
+  toJSVal = return . unMediaStreamAudioDestinationNode
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal MediaStreamAudioDestinationNode where
+  fromJSVal = return . fmap MediaStreamAudioDestinationNode . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsAudioNode MediaStreamAudioDestinationNode
+instance IsEventTarget MediaStreamAudioDestinationNode
+instance IsGObject MediaStreamAudioDestinationNode where
+  typeGType _ = gTypeMediaStreamAudioDestinationNode
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"MediaStreamAudioDestinationNode\"]" gTypeMediaStreamAudioDestinationNode :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.MediaStreamAudioSourceNode".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.AudioNode"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/MediaStreamAudioSourceNode Mozilla MediaStreamAudioSourceNode documentation>
+newtype MediaStreamAudioSourceNode = MediaStreamAudioSourceNode { unMediaStreamAudioSourceNode :: JSVal }
+
+instance Eq (MediaStreamAudioSourceNode) where
+  (MediaStreamAudioSourceNode a) == (MediaStreamAudioSourceNode b) = js_eq a b
+
+instance PToJSVal MediaStreamAudioSourceNode where
+  pToJSVal = unMediaStreamAudioSourceNode
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal MediaStreamAudioSourceNode where
+  pFromJSVal = MediaStreamAudioSourceNode
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal MediaStreamAudioSourceNode where
+  toJSVal = return . unMediaStreamAudioSourceNode
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal MediaStreamAudioSourceNode where
+  fromJSVal = return . fmap MediaStreamAudioSourceNode . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsAudioNode MediaStreamAudioSourceNode
+instance IsEventTarget MediaStreamAudioSourceNode
+instance IsGObject MediaStreamAudioSourceNode where
+  typeGType _ = gTypeMediaStreamAudioSourceNode
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"MediaStreamAudioSourceNode\"]" gTypeMediaStreamAudioSourceNode :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.MediaStreamCapabilities".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/MediaStreamCapabilities Mozilla MediaStreamCapabilities documentation>
+newtype MediaStreamCapabilities = MediaStreamCapabilities { unMediaStreamCapabilities :: JSVal }
+
+instance Eq (MediaStreamCapabilities) where
+  (MediaStreamCapabilities a) == (MediaStreamCapabilities b) = js_eq a b
+
+instance PToJSVal MediaStreamCapabilities where
+  pToJSVal = unMediaStreamCapabilities
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal MediaStreamCapabilities where
+  pFromJSVal = MediaStreamCapabilities
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal MediaStreamCapabilities where
+  toJSVal = return . unMediaStreamCapabilities
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal MediaStreamCapabilities where
+  fromJSVal = return . fmap MediaStreamCapabilities . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+class IsGObject o => IsMediaStreamCapabilities o
+toMediaStreamCapabilities :: IsMediaStreamCapabilities o => o -> MediaStreamCapabilities
+toMediaStreamCapabilities = MediaStreamCapabilities . coerce
+
+instance IsMediaStreamCapabilities MediaStreamCapabilities
+instance IsGObject MediaStreamCapabilities where
+  typeGType _ = gTypeMediaStreamCapabilities
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"MediaStreamCapabilities\"]" gTypeMediaStreamCapabilities :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.MediaStreamEvent".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.Event"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/MediaStreamEvent Mozilla MediaStreamEvent documentation>
+newtype MediaStreamEvent = MediaStreamEvent { unMediaStreamEvent :: JSVal }
+
+instance Eq (MediaStreamEvent) where
+  (MediaStreamEvent a) == (MediaStreamEvent b) = js_eq a b
+
+instance PToJSVal MediaStreamEvent where
+  pToJSVal = unMediaStreamEvent
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal MediaStreamEvent where
+  pFromJSVal = MediaStreamEvent
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal MediaStreamEvent where
+  toJSVal = return . unMediaStreamEvent
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal MediaStreamEvent where
+  fromJSVal = return . fmap MediaStreamEvent . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsEvent MediaStreamEvent
+instance IsGObject MediaStreamEvent where
+  typeGType _ = gTypeMediaStreamEvent
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"MediaStreamEvent\"]" gTypeMediaStreamEvent :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.MediaStreamTrack".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/MediaStreamTrack Mozilla MediaStreamTrack documentation>
+newtype MediaStreamTrack = MediaStreamTrack { unMediaStreamTrack :: JSVal }
+
+instance Eq (MediaStreamTrack) where
+  (MediaStreamTrack a) == (MediaStreamTrack b) = js_eq a b
+
+instance PToJSVal MediaStreamTrack where
+  pToJSVal = unMediaStreamTrack
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal MediaStreamTrack where
+  pFromJSVal = MediaStreamTrack
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal MediaStreamTrack where
+  toJSVal = return . unMediaStreamTrack
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal MediaStreamTrack where
+  fromJSVal = return . fmap MediaStreamTrack . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+class IsEventTarget o => IsMediaStreamTrack o
+toMediaStreamTrack :: IsMediaStreamTrack o => o -> MediaStreamTrack
+toMediaStreamTrack = MediaStreamTrack . coerce
+
+instance IsMediaStreamTrack MediaStreamTrack
+instance IsEventTarget MediaStreamTrack
+instance IsGObject MediaStreamTrack where
+  typeGType _ = gTypeMediaStreamTrack
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"MediaStreamTrack\"]" gTypeMediaStreamTrack :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.MediaStreamTrackEvent".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.Event"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/MediaStreamTrackEvent Mozilla MediaStreamTrackEvent documentation>
+newtype MediaStreamTrackEvent = MediaStreamTrackEvent { unMediaStreamTrackEvent :: JSVal }
+
+instance Eq (MediaStreamTrackEvent) where
+  (MediaStreamTrackEvent a) == (MediaStreamTrackEvent b) = js_eq a b
+
+instance PToJSVal MediaStreamTrackEvent where
+  pToJSVal = unMediaStreamTrackEvent
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal MediaStreamTrackEvent where
+  pFromJSVal = MediaStreamTrackEvent
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal MediaStreamTrackEvent where
+  toJSVal = return . unMediaStreamTrackEvent
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal MediaStreamTrackEvent where
+  fromJSVal = return . fmap MediaStreamTrackEvent . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsEvent MediaStreamTrackEvent
+instance IsGObject MediaStreamTrackEvent where
+  typeGType _ = gTypeMediaStreamTrackEvent
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"MediaStreamTrackEvent\"]" gTypeMediaStreamTrackEvent :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.MediaTrackConstraint".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/MediaTrackConstraint Mozilla MediaTrackConstraint documentation>
+newtype MediaTrackConstraint = MediaTrackConstraint { unMediaTrackConstraint :: JSVal }
+
+instance Eq (MediaTrackConstraint) where
+  (MediaTrackConstraint a) == (MediaTrackConstraint b) = js_eq a b
+
+instance PToJSVal MediaTrackConstraint where
+  pToJSVal = unMediaTrackConstraint
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal MediaTrackConstraint where
+  pFromJSVal = MediaTrackConstraint
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal MediaTrackConstraint where
+  toJSVal = return . unMediaTrackConstraint
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal MediaTrackConstraint where
+  fromJSVal = return . fmap MediaTrackConstraint . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject MediaTrackConstraint where
+  typeGType _ = gTypeMediaTrackConstraint
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"MediaTrackConstraint\"]" gTypeMediaTrackConstraint :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.MediaTrackConstraintSet".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/MediaTrackConstraintSet Mozilla MediaTrackConstraintSet documentation>
+newtype MediaTrackConstraintSet = MediaTrackConstraintSet { unMediaTrackConstraintSet :: JSVal }
+
+instance Eq (MediaTrackConstraintSet) where
+  (MediaTrackConstraintSet a) == (MediaTrackConstraintSet b) = js_eq a b
+
+instance PToJSVal MediaTrackConstraintSet where
+  pToJSVal = unMediaTrackConstraintSet
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal MediaTrackConstraintSet where
+  pFromJSVal = MediaTrackConstraintSet
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal MediaTrackConstraintSet where
+  toJSVal = return . unMediaTrackConstraintSet
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal MediaTrackConstraintSet where
+  fromJSVal = return . fmap MediaTrackConstraintSet . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject MediaTrackConstraintSet where
+  typeGType _ = gTypeMediaTrackConstraintSet
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"MediaTrackConstraintSet\"]" gTypeMediaTrackConstraintSet :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.MediaTrackConstraints".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/MediaTrackConstraints Mozilla MediaTrackConstraints documentation>
+newtype MediaTrackConstraints = MediaTrackConstraints { unMediaTrackConstraints :: JSVal }
+
+instance Eq (MediaTrackConstraints) where
+  (MediaTrackConstraints a) == (MediaTrackConstraints b) = js_eq a b
+
+instance PToJSVal MediaTrackConstraints where
+  pToJSVal = unMediaTrackConstraints
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal MediaTrackConstraints where
+  pFromJSVal = MediaTrackConstraints
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal MediaTrackConstraints where
+  toJSVal = return . unMediaTrackConstraints
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal MediaTrackConstraints where
+  fromJSVal = return . fmap MediaTrackConstraints . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject MediaTrackConstraints where
+  typeGType _ = gTypeMediaTrackConstraints
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"MediaTrackConstraints\"]" gTypeMediaTrackConstraints :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.MemoryInfo".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/MemoryInfo Mozilla MemoryInfo documentation>
+newtype MemoryInfo = MemoryInfo { unMemoryInfo :: JSVal }
+
+instance Eq (MemoryInfo) where
+  (MemoryInfo a) == (MemoryInfo b) = js_eq a b
+
+instance PToJSVal MemoryInfo where
+  pToJSVal = unMemoryInfo
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal MemoryInfo where
+  pFromJSVal = MemoryInfo
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal MemoryInfo where
+  toJSVal = return . unMemoryInfo
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal MemoryInfo where
+  fromJSVal = return . fmap MemoryInfo . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject MemoryInfo where
+  typeGType _ = gTypeMemoryInfo
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"MemoryInfo\"]" gTypeMemoryInfo :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.MessageChannel".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/MessageChannel Mozilla MessageChannel documentation>
+newtype MessageChannel = MessageChannel { unMessageChannel :: JSVal }
+
+instance Eq (MessageChannel) where
+  (MessageChannel a) == (MessageChannel b) = js_eq a b
+
+instance PToJSVal MessageChannel where
+  pToJSVal = unMessageChannel
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal MessageChannel where
+  pFromJSVal = MessageChannel
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal MessageChannel where
+  toJSVal = return . unMessageChannel
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal MessageChannel where
+  fromJSVal = return . fmap MessageChannel . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject MessageChannel where
+  typeGType _ = gTypeMessageChannel
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"MessageChannel\"]" gTypeMessageChannel :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.MessageEvent".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.Event"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/MessageEvent Mozilla MessageEvent documentation>
+newtype MessageEvent = MessageEvent { unMessageEvent :: JSVal }
+
+instance Eq (MessageEvent) where
+  (MessageEvent a) == (MessageEvent b) = js_eq a b
+
+instance PToJSVal MessageEvent where
+  pToJSVal = unMessageEvent
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal MessageEvent where
+  pFromJSVal = MessageEvent
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal MessageEvent where
+  toJSVal = return . unMessageEvent
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal MessageEvent where
+  fromJSVal = return . fmap MessageEvent . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsEvent MessageEvent
+instance IsGObject MessageEvent where
+  typeGType _ = gTypeMessageEvent
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"MessageEvent\"]" gTypeMessageEvent :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.MessagePort".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/MessagePort Mozilla MessagePort documentation>
+newtype MessagePort = MessagePort { unMessagePort :: JSVal }
+
+instance Eq (MessagePort) where
+  (MessagePort a) == (MessagePort b) = js_eq a b
+
+instance PToJSVal MessagePort where
+  pToJSVal = unMessagePort
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal MessagePort where
+  pFromJSVal = MessagePort
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal MessagePort where
+  toJSVal = return . unMessagePort
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal MessagePort where
+  fromJSVal = return . fmap MessagePort . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsEventTarget MessagePort
+instance IsGObject MessagePort where
+  typeGType _ = gTypeMessagePort
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"MessagePort\"]" gTypeMessagePort :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.MimeType".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/MimeType Mozilla MimeType documentation>
+newtype MimeType = MimeType { unMimeType :: JSVal }
+
+instance Eq (MimeType) where
+  (MimeType a) == (MimeType b) = js_eq a b
+
+instance PToJSVal MimeType where
+  pToJSVal = unMimeType
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal MimeType where
+  pFromJSVal = MimeType
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal MimeType where
+  toJSVal = return . unMimeType
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal MimeType where
+  fromJSVal = return . fmap MimeType . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject MimeType where
+  typeGType _ = gTypeMimeType
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"MimeType\"]" gTypeMimeType :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.MimeTypeArray".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/MimeTypeArray Mozilla MimeTypeArray documentation>
+newtype MimeTypeArray = MimeTypeArray { unMimeTypeArray :: JSVal }
+
+instance Eq (MimeTypeArray) where
+  (MimeTypeArray a) == (MimeTypeArray b) = js_eq a b
+
+instance PToJSVal MimeTypeArray where
+  pToJSVal = unMimeTypeArray
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal MimeTypeArray where
+  pFromJSVal = MimeTypeArray
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal MimeTypeArray where
+  toJSVal = return . unMimeTypeArray
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal MimeTypeArray where
+  fromJSVal = return . fmap MimeTypeArray . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject MimeTypeArray where
+  typeGType _ = gTypeMimeTypeArray
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"MimeTypeArray\"]" gTypeMimeTypeArray :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.MouseEvent".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.UIEvent"
+--     * "GHCJS.DOM.Event"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/MouseEvent Mozilla MouseEvent documentation>
+newtype MouseEvent = MouseEvent { unMouseEvent :: JSVal }
+
+instance Eq (MouseEvent) where
+  (MouseEvent a) == (MouseEvent b) = js_eq a b
+
+instance PToJSVal MouseEvent where
+  pToJSVal = unMouseEvent
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal MouseEvent where
+  pFromJSVal = MouseEvent
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal MouseEvent where
+  toJSVal = return . unMouseEvent
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal MouseEvent where
+  fromJSVal = return . fmap MouseEvent . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+class IsUIEvent o => IsMouseEvent o
+toMouseEvent :: IsMouseEvent o => o -> MouseEvent
+toMouseEvent = MouseEvent . coerce
+
+instance IsMouseEvent MouseEvent
+instance IsUIEvent MouseEvent
+instance IsEvent MouseEvent
+instance IsGObject MouseEvent where
+  typeGType _ = gTypeMouseEvent
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"MouseEvent\"]" gTypeMouseEvent :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.MutationEvent".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.Event"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/MutationEvent Mozilla MutationEvent documentation>
+newtype MutationEvent = MutationEvent { unMutationEvent :: JSVal }
+
+instance Eq (MutationEvent) where
+  (MutationEvent a) == (MutationEvent b) = js_eq a b
+
+instance PToJSVal MutationEvent where
+  pToJSVal = unMutationEvent
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal MutationEvent where
+  pFromJSVal = MutationEvent
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal MutationEvent where
+  toJSVal = return . unMutationEvent
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal MutationEvent where
+  fromJSVal = return . fmap MutationEvent . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsEvent MutationEvent
+instance IsGObject MutationEvent where
+  typeGType _ = gTypeMutationEvent
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"MutationEvent\"]" gTypeMutationEvent :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.MutationObserver".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/MutationObserver Mozilla MutationObserver documentation>
+newtype MutationObserver = MutationObserver { unMutationObserver :: JSVal }
+
+instance Eq (MutationObserver) where
+  (MutationObserver a) == (MutationObserver b) = js_eq a b
+
+instance PToJSVal MutationObserver where
+  pToJSVal = unMutationObserver
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal MutationObserver where
+  pFromJSVal = MutationObserver
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal MutationObserver where
+  toJSVal = return . unMutationObserver
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal MutationObserver where
+  fromJSVal = return . fmap MutationObserver . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject MutationObserver where
+  typeGType _ = gTypeMutationObserver
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"MutationObserver\"]" gTypeMutationObserver :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.MutationRecord".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/MutationRecord Mozilla MutationRecord documentation>
+newtype MutationRecord = MutationRecord { unMutationRecord :: JSVal }
+
+instance Eq (MutationRecord) where
+  (MutationRecord a) == (MutationRecord b) = js_eq a b
+
+instance PToJSVal MutationRecord where
+  pToJSVal = unMutationRecord
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal MutationRecord where
+  pFromJSVal = MutationRecord
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal MutationRecord where
+  toJSVal = return . unMutationRecord
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal MutationRecord where
+  fromJSVal = return . fmap MutationRecord . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject MutationRecord where
+  typeGType _ = gTypeMutationRecord
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"MutationRecord\"]" gTypeMutationRecord :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.NamedNodeMap".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/NamedNodeMap Mozilla NamedNodeMap documentation>
+newtype NamedNodeMap = NamedNodeMap { unNamedNodeMap :: JSVal }
+
+instance Eq (NamedNodeMap) where
+  (NamedNodeMap a) == (NamedNodeMap b) = js_eq a b
+
+instance PToJSVal NamedNodeMap where
+  pToJSVal = unNamedNodeMap
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal NamedNodeMap where
+  pFromJSVal = NamedNodeMap
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal NamedNodeMap where
+  toJSVal = return . unNamedNodeMap
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal NamedNodeMap where
+  fromJSVal = return . fmap NamedNodeMap . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject NamedNodeMap where
+  typeGType _ = gTypeNamedNodeMap
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"NamedNodeMap\"]" gTypeNamedNodeMap :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.Navigator".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/Navigator Mozilla Navigator documentation>
+newtype Navigator = Navigator { unNavigator :: JSVal }
+
+instance Eq (Navigator) where
+  (Navigator a) == (Navigator b) = js_eq a b
+
+instance PToJSVal Navigator where
+  pToJSVal = unNavigator
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal Navigator where
+  pFromJSVal = Navigator
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal Navigator where
+  toJSVal = return . unNavigator
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal Navigator where
+  fromJSVal = return . fmap Navigator . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject Navigator where
+  typeGType _ = gTypeNavigator
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"Navigator\"]" gTypeNavigator :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.NavigatorUserMediaError".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.DOMError"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/NavigatorUserMediaError Mozilla NavigatorUserMediaError documentation>
+newtype NavigatorUserMediaError = NavigatorUserMediaError { unNavigatorUserMediaError :: JSVal }
+
+instance Eq (NavigatorUserMediaError) where
+  (NavigatorUserMediaError a) == (NavigatorUserMediaError b) = js_eq a b
+
+instance PToJSVal NavigatorUserMediaError where
+  pToJSVal = unNavigatorUserMediaError
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal NavigatorUserMediaError where
+  pFromJSVal = NavigatorUserMediaError
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal NavigatorUserMediaError where
+  toJSVal = return . unNavigatorUserMediaError
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal NavigatorUserMediaError where
+  fromJSVal = return . fmap NavigatorUserMediaError . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsDOMError NavigatorUserMediaError
+instance IsGObject NavigatorUserMediaError where
+  typeGType _ = gTypeNavigatorUserMediaError
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"NavigatorUserMediaError\"]" gTypeNavigatorUserMediaError :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.Node".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/Node Mozilla Node documentation>
+newtype Node = Node { unNode :: JSVal }
+
+instance Eq (Node) where
+  (Node a) == (Node b) = js_eq a b
+
+instance PToJSVal Node where
+  pToJSVal = unNode
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal Node where
+  pFromJSVal = Node
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal Node where
+  toJSVal = return . unNode
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal Node where
+  fromJSVal = return . fmap Node . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+class IsEventTarget o => IsNode o
+toNode :: IsNode o => o -> Node
+toNode = Node . coerce
+
+instance IsNode Node
+instance IsEventTarget Node
+instance IsGObject Node where
+  typeGType _ = gTypeNode
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"Node\"]" gTypeNode :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.NodeFilter".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/NodeFilter Mozilla NodeFilter documentation>
+newtype NodeFilter = NodeFilter { unNodeFilter :: JSVal }
+
+instance Eq (NodeFilter) where
+  (NodeFilter a) == (NodeFilter b) = js_eq a b
+
+instance PToJSVal NodeFilter where
+  pToJSVal = unNodeFilter
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal NodeFilter where
+  pFromJSVal = NodeFilter
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal NodeFilter where
+  toJSVal = return . unNodeFilter
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal NodeFilter where
+  fromJSVal = return . fmap NodeFilter . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject NodeFilter where
+  typeGType _ = gTypeNodeFilter
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"NodeFilter\"]" gTypeNodeFilter :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.NodeIterator".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/NodeIterator Mozilla NodeIterator documentation>
+newtype NodeIterator = NodeIterator { unNodeIterator :: JSVal }
+
+instance Eq (NodeIterator) where
+  (NodeIterator a) == (NodeIterator b) = js_eq a b
+
+instance PToJSVal NodeIterator where
+  pToJSVal = unNodeIterator
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal NodeIterator where
+  pFromJSVal = NodeIterator
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal NodeIterator where
+  toJSVal = return . unNodeIterator
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal NodeIterator where
+  fromJSVal = return . fmap NodeIterator . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject NodeIterator where
+  typeGType _ = gTypeNodeIterator
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"NodeIterator\"]" gTypeNodeIterator :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.NodeList".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/NodeList Mozilla NodeList documentation>
+newtype NodeList = NodeList { unNodeList :: JSVal }
+
+instance Eq (NodeList) where
+  (NodeList a) == (NodeList b) = js_eq a b
+
+instance PToJSVal NodeList where
+  pToJSVal = unNodeList
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal NodeList where
+  pFromJSVal = NodeList
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal NodeList where
+  toJSVal = return . unNodeList
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal NodeList where
+  fromJSVal = return . fmap NodeList . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+class IsGObject o => IsNodeList o
+toNodeList :: IsNodeList o => o -> NodeList
+toNodeList = NodeList . coerce
+
+instance IsNodeList NodeList
+instance IsGObject NodeList where
+  typeGType _ = gTypeNodeList
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"NodeList\"]" gTypeNodeList :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.Notification".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/Notification Mozilla Notification documentation>
+newtype Notification = Notification { unNotification :: JSVal }
+
+instance Eq (Notification) where
+  (Notification a) == (Notification b) = js_eq a b
+
+instance PToJSVal Notification where
+  pToJSVal = unNotification
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal Notification where
+  pFromJSVal = Notification
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal Notification where
+  toJSVal = return . unNotification
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal Notification where
+  fromJSVal = return . fmap Notification . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsEventTarget Notification
+instance IsGObject Notification where
+  typeGType _ = gTypeNotification
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"Notification\"]" gTypeNotification :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.NotificationCenter".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/NotificationCenter Mozilla NotificationCenter documentation>
+newtype NotificationCenter = NotificationCenter { unNotificationCenter :: JSVal }
+
+instance Eq (NotificationCenter) where
+  (NotificationCenter a) == (NotificationCenter b) = js_eq a b
+
+instance PToJSVal NotificationCenter where
+  pToJSVal = unNotificationCenter
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal NotificationCenter where
+  pFromJSVal = NotificationCenter
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal NotificationCenter where
+  toJSVal = return . unNotificationCenter
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal NotificationCenter where
+  fromJSVal = return . fmap NotificationCenter . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject NotificationCenter where
+  typeGType _ = gTypeNotificationCenter
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"NotificationCenter\"]" gTypeNotificationCenter :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.OESElementIndexUint".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/OESElementIndexUint Mozilla OESElementIndexUint documentation>
+newtype OESElementIndexUint = OESElementIndexUint { unOESElementIndexUint :: JSVal }
+
+instance Eq (OESElementIndexUint) where
+  (OESElementIndexUint a) == (OESElementIndexUint b) = js_eq a b
+
+instance PToJSVal OESElementIndexUint where
+  pToJSVal = unOESElementIndexUint
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal OESElementIndexUint where
+  pFromJSVal = OESElementIndexUint
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal OESElementIndexUint where
+  toJSVal = return . unOESElementIndexUint
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal OESElementIndexUint where
+  fromJSVal = return . fmap OESElementIndexUint . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject OESElementIndexUint where
+  typeGType _ = gTypeOESElementIndexUint
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"OESElementIndexUint\"]" gTypeOESElementIndexUint :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.OESStandardDerivatives".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/OESStandardDerivatives Mozilla OESStandardDerivatives documentation>
+newtype OESStandardDerivatives = OESStandardDerivatives { unOESStandardDerivatives :: JSVal }
+
+instance Eq (OESStandardDerivatives) where
+  (OESStandardDerivatives a) == (OESStandardDerivatives b) = js_eq a b
+
+instance PToJSVal OESStandardDerivatives where
+  pToJSVal = unOESStandardDerivatives
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal OESStandardDerivatives where
+  pFromJSVal = OESStandardDerivatives
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal OESStandardDerivatives where
+  toJSVal = return . unOESStandardDerivatives
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal OESStandardDerivatives where
+  fromJSVal = return . fmap OESStandardDerivatives . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject OESStandardDerivatives where
+  typeGType _ = gTypeOESStandardDerivatives
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"OESStandardDerivatives\"]" gTypeOESStandardDerivatives :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.OESTextureFloat".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/OESTextureFloat Mozilla OESTextureFloat documentation>
+newtype OESTextureFloat = OESTextureFloat { unOESTextureFloat :: JSVal }
+
+instance Eq (OESTextureFloat) where
+  (OESTextureFloat a) == (OESTextureFloat b) = js_eq a b
+
+instance PToJSVal OESTextureFloat where
+  pToJSVal = unOESTextureFloat
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal OESTextureFloat where
+  pFromJSVal = OESTextureFloat
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal OESTextureFloat where
+  toJSVal = return . unOESTextureFloat
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal OESTextureFloat where
+  fromJSVal = return . fmap OESTextureFloat . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject OESTextureFloat where
+  typeGType _ = gTypeOESTextureFloat
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"OESTextureFloat\"]" gTypeOESTextureFloat :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.OESTextureFloatLinear".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/OESTextureFloatLinear Mozilla OESTextureFloatLinear documentation>
+newtype OESTextureFloatLinear = OESTextureFloatLinear { unOESTextureFloatLinear :: JSVal }
+
+instance Eq (OESTextureFloatLinear) where
+  (OESTextureFloatLinear a) == (OESTextureFloatLinear b) = js_eq a b
+
+instance PToJSVal OESTextureFloatLinear where
+  pToJSVal = unOESTextureFloatLinear
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal OESTextureFloatLinear where
+  pFromJSVal = OESTextureFloatLinear
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal OESTextureFloatLinear where
+  toJSVal = return . unOESTextureFloatLinear
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal OESTextureFloatLinear where
+  fromJSVal = return . fmap OESTextureFloatLinear . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject OESTextureFloatLinear where
+  typeGType _ = gTypeOESTextureFloatLinear
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"OESTextureFloatLinear\"]" gTypeOESTextureFloatLinear :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.OESTextureHalfFloat".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/OESTextureHalfFloat Mozilla OESTextureHalfFloat documentation>
+newtype OESTextureHalfFloat = OESTextureHalfFloat { unOESTextureHalfFloat :: JSVal }
+
+instance Eq (OESTextureHalfFloat) where
+  (OESTextureHalfFloat a) == (OESTextureHalfFloat b) = js_eq a b
+
+instance PToJSVal OESTextureHalfFloat where
+  pToJSVal = unOESTextureHalfFloat
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal OESTextureHalfFloat where
+  pFromJSVal = OESTextureHalfFloat
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal OESTextureHalfFloat where
+  toJSVal = return . unOESTextureHalfFloat
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal OESTextureHalfFloat where
+  fromJSVal = return . fmap OESTextureHalfFloat . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject OESTextureHalfFloat where
+  typeGType _ = gTypeOESTextureHalfFloat
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"OESTextureHalfFloat\"]" gTypeOESTextureHalfFloat :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.OESTextureHalfFloatLinear".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/OESTextureHalfFloatLinear Mozilla OESTextureHalfFloatLinear documentation>
+newtype OESTextureHalfFloatLinear = OESTextureHalfFloatLinear { unOESTextureHalfFloatLinear :: JSVal }
+
+instance Eq (OESTextureHalfFloatLinear) where
+  (OESTextureHalfFloatLinear a) == (OESTextureHalfFloatLinear b) = js_eq a b
+
+instance PToJSVal OESTextureHalfFloatLinear where
+  pToJSVal = unOESTextureHalfFloatLinear
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal OESTextureHalfFloatLinear where
+  pFromJSVal = OESTextureHalfFloatLinear
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal OESTextureHalfFloatLinear where
+  toJSVal = return . unOESTextureHalfFloatLinear
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal OESTextureHalfFloatLinear where
+  fromJSVal = return . fmap OESTextureHalfFloatLinear . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject OESTextureHalfFloatLinear where
+  typeGType _ = gTypeOESTextureHalfFloatLinear
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"OESTextureHalfFloatLinear\"]" gTypeOESTextureHalfFloatLinear :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.OESVertexArrayObject".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/OESVertexArrayObject Mozilla OESVertexArrayObject documentation>
+newtype OESVertexArrayObject = OESVertexArrayObject { unOESVertexArrayObject :: JSVal }
+
+instance Eq (OESVertexArrayObject) where
+  (OESVertexArrayObject a) == (OESVertexArrayObject b) = js_eq a b
+
+instance PToJSVal OESVertexArrayObject where
+  pToJSVal = unOESVertexArrayObject
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal OESVertexArrayObject where
+  pFromJSVal = OESVertexArrayObject
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal OESVertexArrayObject where
+  toJSVal = return . unOESVertexArrayObject
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal OESVertexArrayObject where
+  fromJSVal = return . fmap OESVertexArrayObject . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject OESVertexArrayObject where
+  typeGType _ = gTypeOESVertexArrayObject
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"OESVertexArrayObject\"]" gTypeOESVertexArrayObject :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.OfflineAudioCompletionEvent".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.Event"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/OfflineAudioCompletionEvent Mozilla OfflineAudioCompletionEvent documentation>
+newtype OfflineAudioCompletionEvent = OfflineAudioCompletionEvent { unOfflineAudioCompletionEvent :: JSVal }
+
+instance Eq (OfflineAudioCompletionEvent) where
+  (OfflineAudioCompletionEvent a) == (OfflineAudioCompletionEvent b) = js_eq a b
+
+instance PToJSVal OfflineAudioCompletionEvent where
+  pToJSVal = unOfflineAudioCompletionEvent
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal OfflineAudioCompletionEvent where
+  pFromJSVal = OfflineAudioCompletionEvent
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal OfflineAudioCompletionEvent where
+  toJSVal = return . unOfflineAudioCompletionEvent
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal OfflineAudioCompletionEvent where
+  fromJSVal = return . fmap OfflineAudioCompletionEvent . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsEvent OfflineAudioCompletionEvent
+instance IsGObject OfflineAudioCompletionEvent where
+  typeGType _ = gTypeOfflineAudioCompletionEvent
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"OfflineAudioCompletionEvent\"]" gTypeOfflineAudioCompletionEvent :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.OfflineAudioContext".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.AudioContext"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/OfflineAudioContext Mozilla OfflineAudioContext documentation>
+newtype OfflineAudioContext = OfflineAudioContext { unOfflineAudioContext :: JSVal }
+
+instance Eq (OfflineAudioContext) where
+  (OfflineAudioContext a) == (OfflineAudioContext b) = js_eq a b
+
+instance PToJSVal OfflineAudioContext where
+  pToJSVal = unOfflineAudioContext
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal OfflineAudioContext where
+  pFromJSVal = OfflineAudioContext
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal OfflineAudioContext where
+  toJSVal = return . unOfflineAudioContext
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal OfflineAudioContext where
+  fromJSVal = return . fmap OfflineAudioContext . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsAudioContext OfflineAudioContext
+instance IsEventTarget OfflineAudioContext
+instance IsGObject OfflineAudioContext where
+  typeGType _ = gTypeOfflineAudioContext
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"OfflineAudioContext\"]" gTypeOfflineAudioContext :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.OscillatorNode".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.AudioNode"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/OscillatorNode Mozilla OscillatorNode documentation>
+newtype OscillatorNode = OscillatorNode { unOscillatorNode :: JSVal }
+
+instance Eq (OscillatorNode) where
+  (OscillatorNode a) == (OscillatorNode b) = js_eq a b
+
+instance PToJSVal OscillatorNode where
+  pToJSVal = unOscillatorNode
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal OscillatorNode where
+  pFromJSVal = OscillatorNode
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal OscillatorNode where
+  toJSVal = return . unOscillatorNode
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal OscillatorNode where
+  fromJSVal = return . fmap OscillatorNode . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsAudioNode OscillatorNode
+instance IsEventTarget OscillatorNode
+instance IsGObject OscillatorNode where
+  typeGType _ = gTypeOscillatorNode
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"OscillatorNode\"]" gTypeOscillatorNode :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.OverflowEvent".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.Event"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/OverflowEvent Mozilla OverflowEvent documentation>
+newtype OverflowEvent = OverflowEvent { unOverflowEvent :: JSVal }
+
+instance Eq (OverflowEvent) where
+  (OverflowEvent a) == (OverflowEvent b) = js_eq a b
+
+instance PToJSVal OverflowEvent where
+  pToJSVal = unOverflowEvent
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal OverflowEvent where
+  pFromJSVal = OverflowEvent
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal OverflowEvent where
+  toJSVal = return . unOverflowEvent
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal OverflowEvent where
+  fromJSVal = return . fmap OverflowEvent . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsEvent OverflowEvent
+instance IsGObject OverflowEvent where
+  typeGType _ = gTypeOverflowEvent
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"OverflowEvent\"]" gTypeOverflowEvent :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.PageTransitionEvent".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.Event"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/PageTransitionEvent Mozilla PageTransitionEvent documentation>
+newtype PageTransitionEvent = PageTransitionEvent { unPageTransitionEvent :: JSVal }
+
+instance Eq (PageTransitionEvent) where
+  (PageTransitionEvent a) == (PageTransitionEvent b) = js_eq a b
+
+instance PToJSVal PageTransitionEvent where
+  pToJSVal = unPageTransitionEvent
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal PageTransitionEvent where
+  pFromJSVal = PageTransitionEvent
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal PageTransitionEvent where
+  toJSVal = return . unPageTransitionEvent
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal PageTransitionEvent where
+  fromJSVal = return . fmap PageTransitionEvent . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsEvent PageTransitionEvent
+instance IsGObject PageTransitionEvent where
+  typeGType _ = gTypePageTransitionEvent
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"PageTransitionEvent\"]" gTypePageTransitionEvent :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.PannerNode".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.AudioNode"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/webkitAudioPannerNode Mozilla webkitAudioPannerNode documentation>
+newtype PannerNode = PannerNode { unPannerNode :: JSVal }
+
+instance Eq (PannerNode) where
+  (PannerNode a) == (PannerNode b) = js_eq a b
+
+instance PToJSVal PannerNode where
+  pToJSVal = unPannerNode
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal PannerNode where
+  pFromJSVal = PannerNode
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal PannerNode where
+  toJSVal = return . unPannerNode
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal PannerNode where
+  fromJSVal = return . fmap PannerNode . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsAudioNode PannerNode
+instance IsEventTarget PannerNode
+instance IsGObject PannerNode where
+  typeGType _ = gTypePannerNode
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"webkitAudioPannerNode\"]" gTypePannerNode :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.Path2D".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/Path2D Mozilla Path2D documentation>
+newtype Path2D = Path2D { unPath2D :: JSVal }
+
+instance Eq (Path2D) where
+  (Path2D a) == (Path2D b) = js_eq a b
+
+instance PToJSVal Path2D where
+  pToJSVal = unPath2D
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal Path2D where
+  pFromJSVal = Path2D
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal Path2D where
+  toJSVal = return . unPath2D
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal Path2D where
+  fromJSVal = return . fmap Path2D . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject Path2D where
+  typeGType _ = gTypePath2D
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"Path2D\"]" gTypePath2D :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.Performance".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/Performance Mozilla Performance documentation>
+newtype Performance = Performance { unPerformance :: JSVal }
+
+instance Eq (Performance) where
+  (Performance a) == (Performance b) = js_eq a b
+
+instance PToJSVal Performance where
+  pToJSVal = unPerformance
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal Performance where
+  pFromJSVal = Performance
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal Performance where
+  toJSVal = return . unPerformance
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal Performance where
+  fromJSVal = return . fmap Performance . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsEventTarget Performance
+instance IsGObject Performance where
+  typeGType _ = gTypePerformance
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"Performance\"]" gTypePerformance :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.PerformanceEntry".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/PerformanceEntry Mozilla PerformanceEntry documentation>
+newtype PerformanceEntry = PerformanceEntry { unPerformanceEntry :: JSVal }
+
+instance Eq (PerformanceEntry) where
+  (PerformanceEntry a) == (PerformanceEntry b) = js_eq a b
+
+instance PToJSVal PerformanceEntry where
+  pToJSVal = unPerformanceEntry
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal PerformanceEntry where
+  pFromJSVal = PerformanceEntry
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal PerformanceEntry where
+  toJSVal = return . unPerformanceEntry
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal PerformanceEntry where
+  fromJSVal = return . fmap PerformanceEntry . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+class IsGObject o => IsPerformanceEntry o
+toPerformanceEntry :: IsPerformanceEntry o => o -> PerformanceEntry
+toPerformanceEntry = PerformanceEntry . coerce
+
+instance IsPerformanceEntry PerformanceEntry
+instance IsGObject PerformanceEntry where
+  typeGType _ = gTypePerformanceEntry
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"PerformanceEntry\"]" gTypePerformanceEntry :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.PerformanceEntryList".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/PerformanceEntryList Mozilla PerformanceEntryList documentation>
+newtype PerformanceEntryList = PerformanceEntryList { unPerformanceEntryList :: JSVal }
+
+instance Eq (PerformanceEntryList) where
+  (PerformanceEntryList a) == (PerformanceEntryList b) = js_eq a b
+
+instance PToJSVal PerformanceEntryList where
+  pToJSVal = unPerformanceEntryList
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal PerformanceEntryList where
+  pFromJSVal = PerformanceEntryList
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal PerformanceEntryList where
+  toJSVal = return . unPerformanceEntryList
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal PerformanceEntryList where
+  fromJSVal = return . fmap PerformanceEntryList . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject PerformanceEntryList where
+  typeGType _ = gTypePerformanceEntryList
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"PerformanceEntryList\"]" gTypePerformanceEntryList :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.PerformanceMark".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.PerformanceEntry"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/PerformanceMark Mozilla PerformanceMark documentation>
+newtype PerformanceMark = PerformanceMark { unPerformanceMark :: JSVal }
+
+instance Eq (PerformanceMark) where
+  (PerformanceMark a) == (PerformanceMark b) = js_eq a b
+
+instance PToJSVal PerformanceMark where
+  pToJSVal = unPerformanceMark
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal PerformanceMark where
+  pFromJSVal = PerformanceMark
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal PerformanceMark where
+  toJSVal = return . unPerformanceMark
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal PerformanceMark where
+  fromJSVal = return . fmap PerformanceMark . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsPerformanceEntry PerformanceMark
+instance IsGObject PerformanceMark where
+  typeGType _ = gTypePerformanceMark
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"PerformanceMark\"]" gTypePerformanceMark :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.PerformanceMeasure".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.PerformanceEntry"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/PerformanceMeasure Mozilla PerformanceMeasure documentation>
+newtype PerformanceMeasure = PerformanceMeasure { unPerformanceMeasure :: JSVal }
+
+instance Eq (PerformanceMeasure) where
+  (PerformanceMeasure a) == (PerformanceMeasure b) = js_eq a b
+
+instance PToJSVal PerformanceMeasure where
+  pToJSVal = unPerformanceMeasure
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal PerformanceMeasure where
+  pFromJSVal = PerformanceMeasure
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal PerformanceMeasure where
+  toJSVal = return . unPerformanceMeasure
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal PerformanceMeasure where
+  fromJSVal = return . fmap PerformanceMeasure . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsPerformanceEntry PerformanceMeasure
+instance IsGObject PerformanceMeasure where
+  typeGType _ = gTypePerformanceMeasure
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"PerformanceMeasure\"]" gTypePerformanceMeasure :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.PerformanceNavigation".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/PerformanceNavigation Mozilla PerformanceNavigation documentation>
+newtype PerformanceNavigation = PerformanceNavigation { unPerformanceNavigation :: JSVal }
+
+instance Eq (PerformanceNavigation) where
+  (PerformanceNavigation a) == (PerformanceNavigation b) = js_eq a b
+
+instance PToJSVal PerformanceNavigation where
+  pToJSVal = unPerformanceNavigation
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal PerformanceNavigation where
+  pFromJSVal = PerformanceNavigation
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal PerformanceNavigation where
+  toJSVal = return . unPerformanceNavigation
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal PerformanceNavigation where
+  fromJSVal = return . fmap PerformanceNavigation . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject PerformanceNavigation where
+  typeGType _ = gTypePerformanceNavigation
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"PerformanceNavigation\"]" gTypePerformanceNavigation :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.PerformanceResourceTiming".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.PerformanceEntry"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/PerformanceResourceTiming Mozilla PerformanceResourceTiming documentation>
+newtype PerformanceResourceTiming = PerformanceResourceTiming { unPerformanceResourceTiming :: JSVal }
+
+instance Eq (PerformanceResourceTiming) where
+  (PerformanceResourceTiming a) == (PerformanceResourceTiming b) = js_eq a b
+
+instance PToJSVal PerformanceResourceTiming where
+  pToJSVal = unPerformanceResourceTiming
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal PerformanceResourceTiming where
+  pFromJSVal = PerformanceResourceTiming
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal PerformanceResourceTiming where
+  toJSVal = return . unPerformanceResourceTiming
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal PerformanceResourceTiming where
+  fromJSVal = return . fmap PerformanceResourceTiming . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsPerformanceEntry PerformanceResourceTiming
+instance IsGObject PerformanceResourceTiming where
+  typeGType _ = gTypePerformanceResourceTiming
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"PerformanceResourceTiming\"]" gTypePerformanceResourceTiming :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.PerformanceTiming".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/PerformanceTiming Mozilla PerformanceTiming documentation>
+newtype PerformanceTiming = PerformanceTiming { unPerformanceTiming :: JSVal }
+
+instance Eq (PerformanceTiming) where
+  (PerformanceTiming a) == (PerformanceTiming b) = js_eq a b
+
+instance PToJSVal PerformanceTiming where
+  pToJSVal = unPerformanceTiming
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal PerformanceTiming where
+  pFromJSVal = PerformanceTiming
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal PerformanceTiming where
+  toJSVal = return . unPerformanceTiming
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal PerformanceTiming where
+  fromJSVal = return . fmap PerformanceTiming . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject PerformanceTiming where
+  typeGType _ = gTypePerformanceTiming
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"PerformanceTiming\"]" gTypePerformanceTiming :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.PeriodicWave".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/PeriodicWave Mozilla PeriodicWave documentation>
+newtype PeriodicWave = PeriodicWave { unPeriodicWave :: JSVal }
+
+instance Eq (PeriodicWave) where
+  (PeriodicWave a) == (PeriodicWave b) = js_eq a b
+
+instance PToJSVal PeriodicWave where
+  pToJSVal = unPeriodicWave
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal PeriodicWave where
+  pFromJSVal = PeriodicWave
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal PeriodicWave where
+  toJSVal = return . unPeriodicWave
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal PeriodicWave where
+  fromJSVal = return . fmap PeriodicWave . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject PeriodicWave where
+  typeGType _ = gTypePeriodicWave
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"PeriodicWave\"]" gTypePeriodicWave :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.Plugin".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/Plugin Mozilla Plugin documentation>
+newtype Plugin = Plugin { unPlugin :: JSVal }
+
+instance Eq (Plugin) where
+  (Plugin a) == (Plugin b) = js_eq a b
+
+instance PToJSVal Plugin where
+  pToJSVal = unPlugin
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal Plugin where
+  pFromJSVal = Plugin
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal Plugin where
+  toJSVal = return . unPlugin
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal Plugin where
+  fromJSVal = return . fmap Plugin . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject Plugin where
+  typeGType _ = gTypePlugin
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"Plugin\"]" gTypePlugin :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.PluginArray".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/PluginArray Mozilla PluginArray documentation>
+newtype PluginArray = PluginArray { unPluginArray :: JSVal }
+
+instance Eq (PluginArray) where
+  (PluginArray a) == (PluginArray b) = js_eq a b
+
+instance PToJSVal PluginArray where
+  pToJSVal = unPluginArray
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal PluginArray where
+  pFromJSVal = PluginArray
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal PluginArray where
+  toJSVal = return . unPluginArray
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal PluginArray where
+  fromJSVal = return . fmap PluginArray . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject PluginArray where
+  typeGType _ = gTypePluginArray
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"PluginArray\"]" gTypePluginArray :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.PopStateEvent".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.Event"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/PopStateEvent Mozilla PopStateEvent documentation>
+newtype PopStateEvent = PopStateEvent { unPopStateEvent :: JSVal }
+
+instance Eq (PopStateEvent) where
+  (PopStateEvent a) == (PopStateEvent b) = js_eq a b
+
+instance PToJSVal PopStateEvent where
+  pToJSVal = unPopStateEvent
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal PopStateEvent where
+  pFromJSVal = PopStateEvent
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal PopStateEvent where
+  toJSVal = return . unPopStateEvent
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal PopStateEvent where
+  fromJSVal = return . fmap PopStateEvent . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsEvent PopStateEvent
+instance IsGObject PopStateEvent where
+  typeGType _ = gTypePopStateEvent
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"PopStateEvent\"]" gTypePopStateEvent :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.PositionError".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/PositionError Mozilla PositionError documentation>
+newtype PositionError = PositionError { unPositionError :: JSVal }
+
+instance Eq (PositionError) where
+  (PositionError a) == (PositionError b) = js_eq a b
+
+instance PToJSVal PositionError where
+  pToJSVal = unPositionError
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal PositionError where
+  pFromJSVal = PositionError
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal PositionError where
+  toJSVal = return . unPositionError
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal PositionError where
+  fromJSVal = return . fmap PositionError . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject PositionError where
+  typeGType _ = gTypePositionError
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"PositionError\"]" gTypePositionError :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.ProcessingInstruction".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.CharacterData"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/ProcessingInstruction Mozilla ProcessingInstruction documentation>
+newtype ProcessingInstruction = ProcessingInstruction { unProcessingInstruction :: JSVal }
+
+instance Eq (ProcessingInstruction) where
+  (ProcessingInstruction a) == (ProcessingInstruction b) = js_eq a b
+
+instance PToJSVal ProcessingInstruction where
+  pToJSVal = unProcessingInstruction
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal ProcessingInstruction where
+  pFromJSVal = ProcessingInstruction
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal ProcessingInstruction where
+  toJSVal = return . unProcessingInstruction
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal ProcessingInstruction where
+  fromJSVal = return . fmap ProcessingInstruction . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsCharacterData ProcessingInstruction
+instance IsNode ProcessingInstruction
+instance IsEventTarget ProcessingInstruction
+instance IsGObject ProcessingInstruction where
+  typeGType _ = gTypeProcessingInstruction
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"ProcessingInstruction\"]" gTypeProcessingInstruction :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.ProgressEvent".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.Event"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/ProgressEvent Mozilla ProgressEvent documentation>
+newtype ProgressEvent = ProgressEvent { unProgressEvent :: JSVal }
+
+instance Eq (ProgressEvent) where
+  (ProgressEvent a) == (ProgressEvent b) = js_eq a b
+
+instance PToJSVal ProgressEvent where
+  pToJSVal = unProgressEvent
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal ProgressEvent where
+  pFromJSVal = ProgressEvent
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal ProgressEvent where
+  toJSVal = return . unProgressEvent
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal ProgressEvent where
+  fromJSVal = return . fmap ProgressEvent . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+class IsEvent o => IsProgressEvent o
+toProgressEvent :: IsProgressEvent o => o -> ProgressEvent
+toProgressEvent = ProgressEvent . coerce
+
+instance IsProgressEvent ProgressEvent
+instance IsEvent ProgressEvent
+instance IsGObject ProgressEvent where
+  typeGType _ = gTypeProgressEvent
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"ProgressEvent\"]" gTypeProgressEvent :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.QuickTimePluginReplacement".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/QuickTimePluginReplacement Mozilla QuickTimePluginReplacement documentation>
+newtype QuickTimePluginReplacement = QuickTimePluginReplacement { unQuickTimePluginReplacement :: JSVal }
+
+instance Eq (QuickTimePluginReplacement) where
+  (QuickTimePluginReplacement a) == (QuickTimePluginReplacement b) = js_eq a b
+
+instance PToJSVal QuickTimePluginReplacement where
+  pToJSVal = unQuickTimePluginReplacement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal QuickTimePluginReplacement where
+  pFromJSVal = QuickTimePluginReplacement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal QuickTimePluginReplacement where
+  toJSVal = return . unQuickTimePluginReplacement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal QuickTimePluginReplacement where
+  fromJSVal = return . fmap QuickTimePluginReplacement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject QuickTimePluginReplacement where
+  typeGType _ = gTypeQuickTimePluginReplacement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"QuickTimePluginReplacement\"]" gTypeQuickTimePluginReplacement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.RGBColor".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/RGBColor Mozilla RGBColor documentation>
+newtype RGBColor = RGBColor { unRGBColor :: JSVal }
+
+instance Eq (RGBColor) where
+  (RGBColor a) == (RGBColor b) = js_eq a b
+
+instance PToJSVal RGBColor where
+  pToJSVal = unRGBColor
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal RGBColor where
+  pFromJSVal = RGBColor
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal RGBColor where
+  toJSVal = return . unRGBColor
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal RGBColor where
+  fromJSVal = return . fmap RGBColor . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject RGBColor where
+  typeGType _ = gTypeRGBColor
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"RGBColor\"]" gTypeRGBColor :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.RTCConfiguration".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/RTCConfiguration Mozilla RTCConfiguration documentation>
+newtype RTCConfiguration = RTCConfiguration { unRTCConfiguration :: JSVal }
+
+instance Eq (RTCConfiguration) where
+  (RTCConfiguration a) == (RTCConfiguration b) = js_eq a b
+
+instance PToJSVal RTCConfiguration where
+  pToJSVal = unRTCConfiguration
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal RTCConfiguration where
+  pFromJSVal = RTCConfiguration
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal RTCConfiguration where
+  toJSVal = return . unRTCConfiguration
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal RTCConfiguration where
+  fromJSVal = return . fmap RTCConfiguration . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject RTCConfiguration where
+  typeGType _ = gTypeRTCConfiguration
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"RTCConfiguration\"]" gTypeRTCConfiguration :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.RTCDTMFSender".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/RTCDTMFSender Mozilla RTCDTMFSender documentation>
+newtype RTCDTMFSender = RTCDTMFSender { unRTCDTMFSender :: JSVal }
+
+instance Eq (RTCDTMFSender) where
+  (RTCDTMFSender a) == (RTCDTMFSender b) = js_eq a b
+
+instance PToJSVal RTCDTMFSender where
+  pToJSVal = unRTCDTMFSender
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal RTCDTMFSender where
+  pFromJSVal = RTCDTMFSender
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal RTCDTMFSender where
+  toJSVal = return . unRTCDTMFSender
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal RTCDTMFSender where
+  fromJSVal = return . fmap RTCDTMFSender . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsEventTarget RTCDTMFSender
+instance IsGObject RTCDTMFSender where
+  typeGType _ = gTypeRTCDTMFSender
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"RTCDTMFSender\"]" gTypeRTCDTMFSender :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.RTCDTMFToneChangeEvent".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.Event"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/RTCDTMFToneChangeEvent Mozilla RTCDTMFToneChangeEvent documentation>
+newtype RTCDTMFToneChangeEvent = RTCDTMFToneChangeEvent { unRTCDTMFToneChangeEvent :: JSVal }
+
+instance Eq (RTCDTMFToneChangeEvent) where
+  (RTCDTMFToneChangeEvent a) == (RTCDTMFToneChangeEvent b) = js_eq a b
+
+instance PToJSVal RTCDTMFToneChangeEvent where
+  pToJSVal = unRTCDTMFToneChangeEvent
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal RTCDTMFToneChangeEvent where
+  pFromJSVal = RTCDTMFToneChangeEvent
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal RTCDTMFToneChangeEvent where
+  toJSVal = return . unRTCDTMFToneChangeEvent
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal RTCDTMFToneChangeEvent where
+  fromJSVal = return . fmap RTCDTMFToneChangeEvent . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsEvent RTCDTMFToneChangeEvent
+instance IsGObject RTCDTMFToneChangeEvent where
+  typeGType _ = gTypeRTCDTMFToneChangeEvent
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"RTCDTMFToneChangeEvent\"]" gTypeRTCDTMFToneChangeEvent :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.RTCDataChannel".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/RTCDataChannel Mozilla RTCDataChannel documentation>
+newtype RTCDataChannel = RTCDataChannel { unRTCDataChannel :: JSVal }
+
+instance Eq (RTCDataChannel) where
+  (RTCDataChannel a) == (RTCDataChannel b) = js_eq a b
+
+instance PToJSVal RTCDataChannel where
+  pToJSVal = unRTCDataChannel
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal RTCDataChannel where
+  pFromJSVal = RTCDataChannel
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal RTCDataChannel where
+  toJSVal = return . unRTCDataChannel
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal RTCDataChannel where
+  fromJSVal = return . fmap RTCDataChannel . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsEventTarget RTCDataChannel
+instance IsGObject RTCDataChannel where
+  typeGType _ = gTypeRTCDataChannel
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"RTCDataChannel\"]" gTypeRTCDataChannel :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.RTCDataChannelEvent".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.Event"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/RTCDataChannelEvent Mozilla RTCDataChannelEvent documentation>
+newtype RTCDataChannelEvent = RTCDataChannelEvent { unRTCDataChannelEvent :: JSVal }
+
+instance Eq (RTCDataChannelEvent) where
+  (RTCDataChannelEvent a) == (RTCDataChannelEvent b) = js_eq a b
+
+instance PToJSVal RTCDataChannelEvent where
+  pToJSVal = unRTCDataChannelEvent
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal RTCDataChannelEvent where
+  pFromJSVal = RTCDataChannelEvent
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal RTCDataChannelEvent where
+  toJSVal = return . unRTCDataChannelEvent
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal RTCDataChannelEvent where
+  fromJSVal = return . fmap RTCDataChannelEvent . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsEvent RTCDataChannelEvent
+instance IsGObject RTCDataChannelEvent where
+  typeGType _ = gTypeRTCDataChannelEvent
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"RTCDataChannelEvent\"]" gTypeRTCDataChannelEvent :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.RTCIceCandidate".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/RTCIceCandidate Mozilla RTCIceCandidate documentation>
+newtype RTCIceCandidate = RTCIceCandidate { unRTCIceCandidate :: JSVal }
+
+instance Eq (RTCIceCandidate) where
+  (RTCIceCandidate a) == (RTCIceCandidate b) = js_eq a b
+
+instance PToJSVal RTCIceCandidate where
+  pToJSVal = unRTCIceCandidate
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal RTCIceCandidate where
+  pFromJSVal = RTCIceCandidate
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal RTCIceCandidate where
+  toJSVal = return . unRTCIceCandidate
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal RTCIceCandidate where
+  fromJSVal = return . fmap RTCIceCandidate . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject RTCIceCandidate where
+  typeGType _ = gTypeRTCIceCandidate
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"RTCIceCandidate\"]" gTypeRTCIceCandidate :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.RTCIceCandidateEvent".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.Event"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/RTCIceCandidateEvent Mozilla RTCIceCandidateEvent documentation>
+newtype RTCIceCandidateEvent = RTCIceCandidateEvent { unRTCIceCandidateEvent :: JSVal }
+
+instance Eq (RTCIceCandidateEvent) where
+  (RTCIceCandidateEvent a) == (RTCIceCandidateEvent b) = js_eq a b
+
+instance PToJSVal RTCIceCandidateEvent where
+  pToJSVal = unRTCIceCandidateEvent
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal RTCIceCandidateEvent where
+  pFromJSVal = RTCIceCandidateEvent
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal RTCIceCandidateEvent where
+  toJSVal = return . unRTCIceCandidateEvent
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal RTCIceCandidateEvent where
+  fromJSVal = return . fmap RTCIceCandidateEvent . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsEvent RTCIceCandidateEvent
+instance IsGObject RTCIceCandidateEvent where
+  typeGType _ = gTypeRTCIceCandidateEvent
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"RTCIceCandidateEvent\"]" gTypeRTCIceCandidateEvent :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.RTCIceServer".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/RTCIceServer Mozilla RTCIceServer documentation>
+newtype RTCIceServer = RTCIceServer { unRTCIceServer :: JSVal }
+
+instance Eq (RTCIceServer) where
+  (RTCIceServer a) == (RTCIceServer b) = js_eq a b
+
+instance PToJSVal RTCIceServer where
+  pToJSVal = unRTCIceServer
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal RTCIceServer where
+  pFromJSVal = RTCIceServer
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal RTCIceServer where
+  toJSVal = return . unRTCIceServer
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal RTCIceServer where
+  fromJSVal = return . fmap RTCIceServer . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject RTCIceServer where
+  typeGType _ = gTypeRTCIceServer
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"RTCIceServer\"]" gTypeRTCIceServer :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.RTCPeerConnection".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/webkitRTCPeerConnection Mozilla webkitRTCPeerConnection documentation>
+newtype RTCPeerConnection = RTCPeerConnection { unRTCPeerConnection :: JSVal }
+
+instance Eq (RTCPeerConnection) where
+  (RTCPeerConnection a) == (RTCPeerConnection b) = js_eq a b
+
+instance PToJSVal RTCPeerConnection where
+  pToJSVal = unRTCPeerConnection
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal RTCPeerConnection where
+  pFromJSVal = RTCPeerConnection
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal RTCPeerConnection where
+  toJSVal = return . unRTCPeerConnection
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal RTCPeerConnection where
+  fromJSVal = return . fmap RTCPeerConnection . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsEventTarget RTCPeerConnection
+instance IsGObject RTCPeerConnection where
+  typeGType _ = gTypeRTCPeerConnection
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"webkitRTCPeerConnection\"]" gTypeRTCPeerConnection :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.RTCSessionDescription".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/RTCSessionDescription Mozilla RTCSessionDescription documentation>
+newtype RTCSessionDescription = RTCSessionDescription { unRTCSessionDescription :: JSVal }
+
+instance Eq (RTCSessionDescription) where
+  (RTCSessionDescription a) == (RTCSessionDescription b) = js_eq a b
+
+instance PToJSVal RTCSessionDescription where
+  pToJSVal = unRTCSessionDescription
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal RTCSessionDescription where
+  pFromJSVal = RTCSessionDescription
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal RTCSessionDescription where
+  toJSVal = return . unRTCSessionDescription
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal RTCSessionDescription where
+  fromJSVal = return . fmap RTCSessionDescription . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject RTCSessionDescription where
+  typeGType _ = gTypeRTCSessionDescription
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"RTCSessionDescription\"]" gTypeRTCSessionDescription :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.RTCStatsReport".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/RTCStatsReport Mozilla RTCStatsReport documentation>
+newtype RTCStatsReport = RTCStatsReport { unRTCStatsReport :: JSVal }
+
+instance Eq (RTCStatsReport) where
+  (RTCStatsReport a) == (RTCStatsReport b) = js_eq a b
+
+instance PToJSVal RTCStatsReport where
+  pToJSVal = unRTCStatsReport
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal RTCStatsReport where
+  pFromJSVal = RTCStatsReport
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal RTCStatsReport where
+  toJSVal = return . unRTCStatsReport
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal RTCStatsReport where
+  fromJSVal = return . fmap RTCStatsReport . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject RTCStatsReport where
+  typeGType _ = gTypeRTCStatsReport
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"RTCStatsReport\"]" gTypeRTCStatsReport :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.RTCStatsResponse".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/RTCStatsResponse Mozilla RTCStatsResponse documentation>
+newtype RTCStatsResponse = RTCStatsResponse { unRTCStatsResponse :: JSVal }
+
+instance Eq (RTCStatsResponse) where
+  (RTCStatsResponse a) == (RTCStatsResponse b) = js_eq a b
+
+instance PToJSVal RTCStatsResponse where
+  pToJSVal = unRTCStatsResponse
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal RTCStatsResponse where
+  pFromJSVal = RTCStatsResponse
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal RTCStatsResponse where
+  toJSVal = return . unRTCStatsResponse
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal RTCStatsResponse where
+  fromJSVal = return . fmap RTCStatsResponse . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject RTCStatsResponse where
+  typeGType _ = gTypeRTCStatsResponse
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"RTCStatsResponse\"]" gTypeRTCStatsResponse :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.RadioNodeList".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.NodeList"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/RadioNodeList Mozilla RadioNodeList documentation>
+newtype RadioNodeList = RadioNodeList { unRadioNodeList :: JSVal }
+
+instance Eq (RadioNodeList) where
+  (RadioNodeList a) == (RadioNodeList b) = js_eq a b
+
+instance PToJSVal RadioNodeList where
+  pToJSVal = unRadioNodeList
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal RadioNodeList where
+  pFromJSVal = RadioNodeList
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal RadioNodeList where
+  toJSVal = return . unRadioNodeList
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal RadioNodeList where
+  fromJSVal = return . fmap RadioNodeList . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsNodeList RadioNodeList
+instance IsGObject RadioNodeList where
+  typeGType _ = gTypeRadioNodeList
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"RadioNodeList\"]" gTypeRadioNodeList :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.Range".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/Range Mozilla Range documentation>
+newtype Range = Range { unRange :: JSVal }
+
+instance Eq (Range) where
+  (Range a) == (Range b) = js_eq a b
+
+instance PToJSVal Range where
+  pToJSVal = unRange
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal Range where
+  pFromJSVal = Range
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal Range where
+  toJSVal = return . unRange
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal Range where
+  fromJSVal = return . fmap Range . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject Range where
+  typeGType _ = gTypeRange
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"Range\"]" gTypeRange :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.ReadableStream".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream Mozilla ReadableStream documentation>
+newtype ReadableStream = ReadableStream { unReadableStream :: JSVal }
+
+instance Eq (ReadableStream) where
+  (ReadableStream a) == (ReadableStream b) = js_eq a b
+
+instance PToJSVal ReadableStream where
+  pToJSVal = unReadableStream
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal ReadableStream where
+  pFromJSVal = ReadableStream
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal ReadableStream where
+  toJSVal = return . unReadableStream
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal ReadableStream where
+  fromJSVal = return . fmap ReadableStream . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject ReadableStream where
+  typeGType _ = gTypeReadableStream
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"ReadableStream\"]" gTypeReadableStream :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.Rect".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/Rect Mozilla Rect documentation>
+newtype Rect = Rect { unRect :: JSVal }
+
+instance Eq (Rect) where
+  (Rect a) == (Rect b) = js_eq a b
+
+instance PToJSVal Rect where
+  pToJSVal = unRect
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal Rect where
+  pFromJSVal = Rect
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal Rect where
+  toJSVal = return . unRect
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal Rect where
+  fromJSVal = return . fmap Rect . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject Rect where
+  typeGType _ = gTypeRect
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"Rect\"]" gTypeRect :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SQLError".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SQLError Mozilla SQLError documentation>
+newtype SQLError = SQLError { unSQLError :: JSVal }
+
+instance Eq (SQLError) where
+  (SQLError a) == (SQLError b) = js_eq a b
+
+instance PToJSVal SQLError where
+  pToJSVal = unSQLError
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SQLError where
+  pFromJSVal = SQLError
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SQLError where
+  toJSVal = return . unSQLError
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SQLError where
+  fromJSVal = return . fmap SQLError . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject SQLError where
+  typeGType _ = gTypeSQLError
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SQLError\"]" gTypeSQLError :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SQLResultSet".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SQLResultSet Mozilla SQLResultSet documentation>
+newtype SQLResultSet = SQLResultSet { unSQLResultSet :: JSVal }
+
+instance Eq (SQLResultSet) where
+  (SQLResultSet a) == (SQLResultSet b) = js_eq a b
+
+instance PToJSVal SQLResultSet where
+  pToJSVal = unSQLResultSet
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SQLResultSet where
+  pFromJSVal = SQLResultSet
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SQLResultSet where
+  toJSVal = return . unSQLResultSet
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SQLResultSet where
+  fromJSVal = return . fmap SQLResultSet . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject SQLResultSet where
+  typeGType _ = gTypeSQLResultSet
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SQLResultSet\"]" gTypeSQLResultSet :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SQLResultSetRowList".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SQLResultSetRowList Mozilla SQLResultSetRowList documentation>
+newtype SQLResultSetRowList = SQLResultSetRowList { unSQLResultSetRowList :: JSVal }
+
+instance Eq (SQLResultSetRowList) where
+  (SQLResultSetRowList a) == (SQLResultSetRowList b) = js_eq a b
+
+instance PToJSVal SQLResultSetRowList where
+  pToJSVal = unSQLResultSetRowList
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SQLResultSetRowList where
+  pFromJSVal = SQLResultSetRowList
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SQLResultSetRowList where
+  toJSVal = return . unSQLResultSetRowList
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SQLResultSetRowList where
+  fromJSVal = return . fmap SQLResultSetRowList . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject SQLResultSetRowList where
+  typeGType _ = gTypeSQLResultSetRowList
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SQLResultSetRowList\"]" gTypeSQLResultSetRowList :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SQLTransaction".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SQLTransaction Mozilla SQLTransaction documentation>
+newtype SQLTransaction = SQLTransaction { unSQLTransaction :: JSVal }
+
+instance Eq (SQLTransaction) where
+  (SQLTransaction a) == (SQLTransaction b) = js_eq a b
+
+instance PToJSVal SQLTransaction where
+  pToJSVal = unSQLTransaction
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SQLTransaction where
+  pFromJSVal = SQLTransaction
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SQLTransaction where
+  toJSVal = return . unSQLTransaction
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SQLTransaction where
+  fromJSVal = return . fmap SQLTransaction . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject SQLTransaction where
+  typeGType _ = gTypeSQLTransaction
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SQLTransaction\"]" gTypeSQLTransaction :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SVGAElement".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.SVGGraphicsElement"
+--     * "GHCJS.DOM.SVGElement"
+--     * "GHCJS.DOM.Element"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SVGAElement Mozilla SVGAElement documentation>
+newtype SVGAElement = SVGAElement { unSVGAElement :: JSVal }
+
+instance Eq (SVGAElement) where
+  (SVGAElement a) == (SVGAElement b) = js_eq a b
+
+instance PToJSVal SVGAElement where
+  pToJSVal = unSVGAElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SVGAElement where
+  pFromJSVal = SVGAElement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SVGAElement where
+  toJSVal = return . unSVGAElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SVGAElement where
+  fromJSVal = return . fmap SVGAElement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsSVGGraphicsElement SVGAElement
+instance IsSVGElement SVGAElement
+instance IsElement SVGAElement
+instance IsNode SVGAElement
+instance IsEventTarget SVGAElement
+instance IsGObject SVGAElement where
+  typeGType _ = gTypeSVGAElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SVGAElement\"]" gTypeSVGAElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SVGAltGlyphDefElement".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.SVGElement"
+--     * "GHCJS.DOM.Element"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SVGAltGlyphDefElement Mozilla SVGAltGlyphDefElement documentation>
+newtype SVGAltGlyphDefElement = SVGAltGlyphDefElement { unSVGAltGlyphDefElement :: JSVal }
+
+instance Eq (SVGAltGlyphDefElement) where
+  (SVGAltGlyphDefElement a) == (SVGAltGlyphDefElement b) = js_eq a b
+
+instance PToJSVal SVGAltGlyphDefElement where
+  pToJSVal = unSVGAltGlyphDefElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SVGAltGlyphDefElement where
+  pFromJSVal = SVGAltGlyphDefElement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SVGAltGlyphDefElement where
+  toJSVal = return . unSVGAltGlyphDefElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SVGAltGlyphDefElement where
+  fromJSVal = return . fmap SVGAltGlyphDefElement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsSVGElement SVGAltGlyphDefElement
+instance IsElement SVGAltGlyphDefElement
+instance IsNode SVGAltGlyphDefElement
+instance IsEventTarget SVGAltGlyphDefElement
+instance IsGObject SVGAltGlyphDefElement where
+  typeGType _ = gTypeSVGAltGlyphDefElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SVGAltGlyphDefElement\"]" gTypeSVGAltGlyphDefElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SVGAltGlyphElement".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.SVGTextPositioningElement"
+--     * "GHCJS.DOM.SVGTextContentElement"
+--     * "GHCJS.DOM.SVGGraphicsElement"
+--     * "GHCJS.DOM.SVGElement"
+--     * "GHCJS.DOM.Element"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SVGAltGlyphElement Mozilla SVGAltGlyphElement documentation>
+newtype SVGAltGlyphElement = SVGAltGlyphElement { unSVGAltGlyphElement :: JSVal }
+
+instance Eq (SVGAltGlyphElement) where
+  (SVGAltGlyphElement a) == (SVGAltGlyphElement b) = js_eq a b
+
+instance PToJSVal SVGAltGlyphElement where
+  pToJSVal = unSVGAltGlyphElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SVGAltGlyphElement where
+  pFromJSVal = SVGAltGlyphElement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SVGAltGlyphElement where
+  toJSVal = return . unSVGAltGlyphElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SVGAltGlyphElement where
+  fromJSVal = return . fmap SVGAltGlyphElement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsSVGTextPositioningElement SVGAltGlyphElement
+instance IsSVGTextContentElement SVGAltGlyphElement
+instance IsSVGGraphicsElement SVGAltGlyphElement
+instance IsSVGElement SVGAltGlyphElement
+instance IsElement SVGAltGlyphElement
+instance IsNode SVGAltGlyphElement
+instance IsEventTarget SVGAltGlyphElement
+instance IsGObject SVGAltGlyphElement where
+  typeGType _ = gTypeSVGAltGlyphElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SVGAltGlyphElement\"]" gTypeSVGAltGlyphElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SVGAltGlyphItemElement".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.SVGElement"
+--     * "GHCJS.DOM.Element"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SVGAltGlyphItemElement Mozilla SVGAltGlyphItemElement documentation>
+newtype SVGAltGlyphItemElement = SVGAltGlyphItemElement { unSVGAltGlyphItemElement :: JSVal }
+
+instance Eq (SVGAltGlyphItemElement) where
+  (SVGAltGlyphItemElement a) == (SVGAltGlyphItemElement b) = js_eq a b
+
+instance PToJSVal SVGAltGlyphItemElement where
+  pToJSVal = unSVGAltGlyphItemElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SVGAltGlyphItemElement where
+  pFromJSVal = SVGAltGlyphItemElement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SVGAltGlyphItemElement where
+  toJSVal = return . unSVGAltGlyphItemElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SVGAltGlyphItemElement where
+  fromJSVal = return . fmap SVGAltGlyphItemElement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsSVGElement SVGAltGlyphItemElement
+instance IsElement SVGAltGlyphItemElement
+instance IsNode SVGAltGlyphItemElement
+instance IsEventTarget SVGAltGlyphItemElement
+instance IsGObject SVGAltGlyphItemElement where
+  typeGType _ = gTypeSVGAltGlyphItemElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SVGAltGlyphItemElement\"]" gTypeSVGAltGlyphItemElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SVGAngle".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SVGAngle Mozilla SVGAngle documentation>
+newtype SVGAngle = SVGAngle { unSVGAngle :: JSVal }
+
+instance Eq (SVGAngle) where
+  (SVGAngle a) == (SVGAngle b) = js_eq a b
+
+instance PToJSVal SVGAngle where
+  pToJSVal = unSVGAngle
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SVGAngle where
+  pFromJSVal = SVGAngle
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SVGAngle where
+  toJSVal = return . unSVGAngle
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SVGAngle where
+  fromJSVal = return . fmap SVGAngle . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject SVGAngle where
+  typeGType _ = gTypeSVGAngle
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SVGAngle\"]" gTypeSVGAngle :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SVGAnimateColorElement".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.SVGAnimationElement"
+--     * "GHCJS.DOM.SVGElement"
+--     * "GHCJS.DOM.Element"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SVGAnimateColorElement Mozilla SVGAnimateColorElement documentation>
+newtype SVGAnimateColorElement = SVGAnimateColorElement { unSVGAnimateColorElement :: JSVal }
+
+instance Eq (SVGAnimateColorElement) where
+  (SVGAnimateColorElement a) == (SVGAnimateColorElement b) = js_eq a b
+
+instance PToJSVal SVGAnimateColorElement where
+  pToJSVal = unSVGAnimateColorElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SVGAnimateColorElement where
+  pFromJSVal = SVGAnimateColorElement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SVGAnimateColorElement where
+  toJSVal = return . unSVGAnimateColorElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SVGAnimateColorElement where
+  fromJSVal = return . fmap SVGAnimateColorElement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsSVGAnimationElement SVGAnimateColorElement
+instance IsSVGElement SVGAnimateColorElement
+instance IsElement SVGAnimateColorElement
+instance IsNode SVGAnimateColorElement
+instance IsEventTarget SVGAnimateColorElement
+instance IsGObject SVGAnimateColorElement where
+  typeGType _ = gTypeSVGAnimateColorElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SVGAnimateColorElement\"]" gTypeSVGAnimateColorElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SVGAnimateElement".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.SVGAnimationElement"
+--     * "GHCJS.DOM.SVGElement"
+--     * "GHCJS.DOM.Element"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SVGAnimateElement Mozilla SVGAnimateElement documentation>
+newtype SVGAnimateElement = SVGAnimateElement { unSVGAnimateElement :: JSVal }
+
+instance Eq (SVGAnimateElement) where
+  (SVGAnimateElement a) == (SVGAnimateElement b) = js_eq a b
+
+instance PToJSVal SVGAnimateElement where
+  pToJSVal = unSVGAnimateElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SVGAnimateElement where
+  pFromJSVal = SVGAnimateElement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SVGAnimateElement where
+  toJSVal = return . unSVGAnimateElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SVGAnimateElement where
+  fromJSVal = return . fmap SVGAnimateElement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsSVGAnimationElement SVGAnimateElement
+instance IsSVGElement SVGAnimateElement
+instance IsElement SVGAnimateElement
+instance IsNode SVGAnimateElement
+instance IsEventTarget SVGAnimateElement
+instance IsGObject SVGAnimateElement where
+  typeGType _ = gTypeSVGAnimateElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SVGAnimateElement\"]" gTypeSVGAnimateElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SVGAnimateMotionElement".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.SVGAnimationElement"
+--     * "GHCJS.DOM.SVGElement"
+--     * "GHCJS.DOM.Element"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SVGAnimateMotionElement Mozilla SVGAnimateMotionElement documentation>
+newtype SVGAnimateMotionElement = SVGAnimateMotionElement { unSVGAnimateMotionElement :: JSVal }
+
+instance Eq (SVGAnimateMotionElement) where
+  (SVGAnimateMotionElement a) == (SVGAnimateMotionElement b) = js_eq a b
+
+instance PToJSVal SVGAnimateMotionElement where
+  pToJSVal = unSVGAnimateMotionElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SVGAnimateMotionElement where
+  pFromJSVal = SVGAnimateMotionElement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SVGAnimateMotionElement where
+  toJSVal = return . unSVGAnimateMotionElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SVGAnimateMotionElement where
+  fromJSVal = return . fmap SVGAnimateMotionElement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsSVGAnimationElement SVGAnimateMotionElement
+instance IsSVGElement SVGAnimateMotionElement
+instance IsElement SVGAnimateMotionElement
+instance IsNode SVGAnimateMotionElement
+instance IsEventTarget SVGAnimateMotionElement
+instance IsGObject SVGAnimateMotionElement where
+  typeGType _ = gTypeSVGAnimateMotionElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SVGAnimateMotionElement\"]" gTypeSVGAnimateMotionElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SVGAnimateTransformElement".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.SVGAnimationElement"
+--     * "GHCJS.DOM.SVGElement"
+--     * "GHCJS.DOM.Element"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SVGAnimateTransformElement Mozilla SVGAnimateTransformElement documentation>
+newtype SVGAnimateTransformElement = SVGAnimateTransformElement { unSVGAnimateTransformElement :: JSVal }
+
+instance Eq (SVGAnimateTransformElement) where
+  (SVGAnimateTransformElement a) == (SVGAnimateTransformElement b) = js_eq a b
+
+instance PToJSVal SVGAnimateTransformElement where
+  pToJSVal = unSVGAnimateTransformElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SVGAnimateTransformElement where
+  pFromJSVal = SVGAnimateTransformElement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SVGAnimateTransformElement where
+  toJSVal = return . unSVGAnimateTransformElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SVGAnimateTransformElement where
+  fromJSVal = return . fmap SVGAnimateTransformElement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsSVGAnimationElement SVGAnimateTransformElement
+instance IsSVGElement SVGAnimateTransformElement
+instance IsElement SVGAnimateTransformElement
+instance IsNode SVGAnimateTransformElement
+instance IsEventTarget SVGAnimateTransformElement
+instance IsGObject SVGAnimateTransformElement where
+  typeGType _ = gTypeSVGAnimateTransformElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SVGAnimateTransformElement\"]" gTypeSVGAnimateTransformElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SVGAnimatedAngle".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SVGAnimatedAngle Mozilla SVGAnimatedAngle documentation>
+newtype SVGAnimatedAngle = SVGAnimatedAngle { unSVGAnimatedAngle :: JSVal }
+
+instance Eq (SVGAnimatedAngle) where
+  (SVGAnimatedAngle a) == (SVGAnimatedAngle b) = js_eq a b
+
+instance PToJSVal SVGAnimatedAngle where
+  pToJSVal = unSVGAnimatedAngle
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SVGAnimatedAngle where
+  pFromJSVal = SVGAnimatedAngle
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SVGAnimatedAngle where
+  toJSVal = return . unSVGAnimatedAngle
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SVGAnimatedAngle where
+  fromJSVal = return . fmap SVGAnimatedAngle . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject SVGAnimatedAngle where
+  typeGType _ = gTypeSVGAnimatedAngle
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SVGAnimatedAngle\"]" gTypeSVGAnimatedAngle :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SVGAnimatedBoolean".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SVGAnimatedBoolean Mozilla SVGAnimatedBoolean documentation>
+newtype SVGAnimatedBoolean = SVGAnimatedBoolean { unSVGAnimatedBoolean :: JSVal }
+
+instance Eq (SVGAnimatedBoolean) where
+  (SVGAnimatedBoolean a) == (SVGAnimatedBoolean b) = js_eq a b
+
+instance PToJSVal SVGAnimatedBoolean where
+  pToJSVal = unSVGAnimatedBoolean
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SVGAnimatedBoolean where
+  pFromJSVal = SVGAnimatedBoolean
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SVGAnimatedBoolean where
+  toJSVal = return . unSVGAnimatedBoolean
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SVGAnimatedBoolean where
+  fromJSVal = return . fmap SVGAnimatedBoolean . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject SVGAnimatedBoolean where
+  typeGType _ = gTypeSVGAnimatedBoolean
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SVGAnimatedBoolean\"]" gTypeSVGAnimatedBoolean :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SVGAnimatedEnumeration".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SVGAnimatedEnumeration Mozilla SVGAnimatedEnumeration documentation>
+newtype SVGAnimatedEnumeration = SVGAnimatedEnumeration { unSVGAnimatedEnumeration :: JSVal }
+
+instance Eq (SVGAnimatedEnumeration) where
+  (SVGAnimatedEnumeration a) == (SVGAnimatedEnumeration b) = js_eq a b
+
+instance PToJSVal SVGAnimatedEnumeration where
+  pToJSVal = unSVGAnimatedEnumeration
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SVGAnimatedEnumeration where
+  pFromJSVal = SVGAnimatedEnumeration
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SVGAnimatedEnumeration where
+  toJSVal = return . unSVGAnimatedEnumeration
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SVGAnimatedEnumeration where
+  fromJSVal = return . fmap SVGAnimatedEnumeration . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject SVGAnimatedEnumeration where
+  typeGType _ = gTypeSVGAnimatedEnumeration
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SVGAnimatedEnumeration\"]" gTypeSVGAnimatedEnumeration :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SVGAnimatedInteger".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SVGAnimatedInteger Mozilla SVGAnimatedInteger documentation>
+newtype SVGAnimatedInteger = SVGAnimatedInteger { unSVGAnimatedInteger :: JSVal }
+
+instance Eq (SVGAnimatedInteger) where
+  (SVGAnimatedInteger a) == (SVGAnimatedInteger b) = js_eq a b
+
+instance PToJSVal SVGAnimatedInteger where
+  pToJSVal = unSVGAnimatedInteger
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SVGAnimatedInteger where
+  pFromJSVal = SVGAnimatedInteger
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SVGAnimatedInteger where
+  toJSVal = return . unSVGAnimatedInteger
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SVGAnimatedInteger where
+  fromJSVal = return . fmap SVGAnimatedInteger . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject SVGAnimatedInteger where
+  typeGType _ = gTypeSVGAnimatedInteger
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SVGAnimatedInteger\"]" gTypeSVGAnimatedInteger :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SVGAnimatedLength".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SVGAnimatedLength Mozilla SVGAnimatedLength documentation>
+newtype SVGAnimatedLength = SVGAnimatedLength { unSVGAnimatedLength :: JSVal }
+
+instance Eq (SVGAnimatedLength) where
+  (SVGAnimatedLength a) == (SVGAnimatedLength b) = js_eq a b
+
+instance PToJSVal SVGAnimatedLength where
+  pToJSVal = unSVGAnimatedLength
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SVGAnimatedLength where
+  pFromJSVal = SVGAnimatedLength
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SVGAnimatedLength where
+  toJSVal = return . unSVGAnimatedLength
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SVGAnimatedLength where
+  fromJSVal = return . fmap SVGAnimatedLength . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject SVGAnimatedLength where
+  typeGType _ = gTypeSVGAnimatedLength
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SVGAnimatedLength\"]" gTypeSVGAnimatedLength :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SVGAnimatedLengthList".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SVGAnimatedLengthList Mozilla SVGAnimatedLengthList documentation>
+newtype SVGAnimatedLengthList = SVGAnimatedLengthList { unSVGAnimatedLengthList :: JSVal }
+
+instance Eq (SVGAnimatedLengthList) where
+  (SVGAnimatedLengthList a) == (SVGAnimatedLengthList b) = js_eq a b
+
+instance PToJSVal SVGAnimatedLengthList where
+  pToJSVal = unSVGAnimatedLengthList
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SVGAnimatedLengthList where
+  pFromJSVal = SVGAnimatedLengthList
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SVGAnimatedLengthList where
+  toJSVal = return . unSVGAnimatedLengthList
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SVGAnimatedLengthList where
+  fromJSVal = return . fmap SVGAnimatedLengthList . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject SVGAnimatedLengthList where
+  typeGType _ = gTypeSVGAnimatedLengthList
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SVGAnimatedLengthList\"]" gTypeSVGAnimatedLengthList :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SVGAnimatedNumber".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SVGAnimatedNumber Mozilla SVGAnimatedNumber documentation>
+newtype SVGAnimatedNumber = SVGAnimatedNumber { unSVGAnimatedNumber :: JSVal }
+
+instance Eq (SVGAnimatedNumber) where
+  (SVGAnimatedNumber a) == (SVGAnimatedNumber b) = js_eq a b
+
+instance PToJSVal SVGAnimatedNumber where
+  pToJSVal = unSVGAnimatedNumber
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SVGAnimatedNumber where
+  pFromJSVal = SVGAnimatedNumber
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SVGAnimatedNumber where
+  toJSVal = return . unSVGAnimatedNumber
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SVGAnimatedNumber where
+  fromJSVal = return . fmap SVGAnimatedNumber . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject SVGAnimatedNumber where
+  typeGType _ = gTypeSVGAnimatedNumber
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SVGAnimatedNumber\"]" gTypeSVGAnimatedNumber :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SVGAnimatedNumberList".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SVGAnimatedNumberList Mozilla SVGAnimatedNumberList documentation>
+newtype SVGAnimatedNumberList = SVGAnimatedNumberList { unSVGAnimatedNumberList :: JSVal }
+
+instance Eq (SVGAnimatedNumberList) where
+  (SVGAnimatedNumberList a) == (SVGAnimatedNumberList b) = js_eq a b
+
+instance PToJSVal SVGAnimatedNumberList where
+  pToJSVal = unSVGAnimatedNumberList
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SVGAnimatedNumberList where
+  pFromJSVal = SVGAnimatedNumberList
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SVGAnimatedNumberList where
+  toJSVal = return . unSVGAnimatedNumberList
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SVGAnimatedNumberList where
+  fromJSVal = return . fmap SVGAnimatedNumberList . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject SVGAnimatedNumberList where
+  typeGType _ = gTypeSVGAnimatedNumberList
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SVGAnimatedNumberList\"]" gTypeSVGAnimatedNumberList :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SVGAnimatedPreserveAspectRatio".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SVGAnimatedPreserveAspectRatio Mozilla SVGAnimatedPreserveAspectRatio documentation>
+newtype SVGAnimatedPreserveAspectRatio = SVGAnimatedPreserveAspectRatio { unSVGAnimatedPreserveAspectRatio :: JSVal }
+
+instance Eq (SVGAnimatedPreserveAspectRatio) where
+  (SVGAnimatedPreserveAspectRatio a) == (SVGAnimatedPreserveAspectRatio b) = js_eq a b
+
+instance PToJSVal SVGAnimatedPreserveAspectRatio where
+  pToJSVal = unSVGAnimatedPreserveAspectRatio
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SVGAnimatedPreserveAspectRatio where
+  pFromJSVal = SVGAnimatedPreserveAspectRatio
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SVGAnimatedPreserveAspectRatio where
+  toJSVal = return . unSVGAnimatedPreserveAspectRatio
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SVGAnimatedPreserveAspectRatio where
+  fromJSVal = return . fmap SVGAnimatedPreserveAspectRatio . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject SVGAnimatedPreserveAspectRatio where
+  typeGType _ = gTypeSVGAnimatedPreserveAspectRatio
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SVGAnimatedPreserveAspectRatio\"]" gTypeSVGAnimatedPreserveAspectRatio :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SVGAnimatedRect".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SVGAnimatedRect Mozilla SVGAnimatedRect documentation>
+newtype SVGAnimatedRect = SVGAnimatedRect { unSVGAnimatedRect :: JSVal }
+
+instance Eq (SVGAnimatedRect) where
+  (SVGAnimatedRect a) == (SVGAnimatedRect b) = js_eq a b
+
+instance PToJSVal SVGAnimatedRect where
+  pToJSVal = unSVGAnimatedRect
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SVGAnimatedRect where
+  pFromJSVal = SVGAnimatedRect
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SVGAnimatedRect where
+  toJSVal = return . unSVGAnimatedRect
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SVGAnimatedRect where
+  fromJSVal = return . fmap SVGAnimatedRect . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject SVGAnimatedRect where
+  typeGType _ = gTypeSVGAnimatedRect
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SVGAnimatedRect\"]" gTypeSVGAnimatedRect :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SVGAnimatedString".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SVGAnimatedString Mozilla SVGAnimatedString documentation>
+newtype SVGAnimatedString = SVGAnimatedString { unSVGAnimatedString :: JSVal }
+
+instance Eq (SVGAnimatedString) where
+  (SVGAnimatedString a) == (SVGAnimatedString b) = js_eq a b
+
+instance PToJSVal SVGAnimatedString where
+  pToJSVal = unSVGAnimatedString
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SVGAnimatedString where
+  pFromJSVal = SVGAnimatedString
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SVGAnimatedString where
+  toJSVal = return . unSVGAnimatedString
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SVGAnimatedString where
+  fromJSVal = return . fmap SVGAnimatedString . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject SVGAnimatedString where
+  typeGType _ = gTypeSVGAnimatedString
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SVGAnimatedString\"]" gTypeSVGAnimatedString :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SVGAnimatedTransformList".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SVGAnimatedTransformList Mozilla SVGAnimatedTransformList documentation>
+newtype SVGAnimatedTransformList = SVGAnimatedTransformList { unSVGAnimatedTransformList :: JSVal }
+
+instance Eq (SVGAnimatedTransformList) where
+  (SVGAnimatedTransformList a) == (SVGAnimatedTransformList b) = js_eq a b
+
+instance PToJSVal SVGAnimatedTransformList where
+  pToJSVal = unSVGAnimatedTransformList
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SVGAnimatedTransformList where
+  pFromJSVal = SVGAnimatedTransformList
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SVGAnimatedTransformList where
+  toJSVal = return . unSVGAnimatedTransformList
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SVGAnimatedTransformList where
+  fromJSVal = return . fmap SVGAnimatedTransformList . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject SVGAnimatedTransformList where
+  typeGType _ = gTypeSVGAnimatedTransformList
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SVGAnimatedTransformList\"]" gTypeSVGAnimatedTransformList :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SVGAnimationElement".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.SVGElement"
+--     * "GHCJS.DOM.Element"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SVGAnimationElement Mozilla SVGAnimationElement documentation>
+newtype SVGAnimationElement = SVGAnimationElement { unSVGAnimationElement :: JSVal }
+
+instance Eq (SVGAnimationElement) where
+  (SVGAnimationElement a) == (SVGAnimationElement b) = js_eq a b
+
+instance PToJSVal SVGAnimationElement where
+  pToJSVal = unSVGAnimationElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SVGAnimationElement where
+  pFromJSVal = SVGAnimationElement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SVGAnimationElement where
+  toJSVal = return . unSVGAnimationElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SVGAnimationElement where
+  fromJSVal = return . fmap SVGAnimationElement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+class IsSVGElement o => IsSVGAnimationElement o
+toSVGAnimationElement :: IsSVGAnimationElement o => o -> SVGAnimationElement
+toSVGAnimationElement = SVGAnimationElement . coerce
+
+instance IsSVGAnimationElement SVGAnimationElement
+instance IsSVGElement SVGAnimationElement
+instance IsElement SVGAnimationElement
+instance IsNode SVGAnimationElement
+instance IsEventTarget SVGAnimationElement
+instance IsGObject SVGAnimationElement where
+  typeGType _ = gTypeSVGAnimationElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SVGAnimationElement\"]" gTypeSVGAnimationElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SVGCircleElement".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.SVGGraphicsElement"
+--     * "GHCJS.DOM.SVGElement"
+--     * "GHCJS.DOM.Element"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SVGCircleElement Mozilla SVGCircleElement documentation>
+newtype SVGCircleElement = SVGCircleElement { unSVGCircleElement :: JSVal }
+
+instance Eq (SVGCircleElement) where
+  (SVGCircleElement a) == (SVGCircleElement b) = js_eq a b
+
+instance PToJSVal SVGCircleElement where
+  pToJSVal = unSVGCircleElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SVGCircleElement where
+  pFromJSVal = SVGCircleElement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SVGCircleElement where
+  toJSVal = return . unSVGCircleElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SVGCircleElement where
+  fromJSVal = return . fmap SVGCircleElement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsSVGGraphicsElement SVGCircleElement
+instance IsSVGElement SVGCircleElement
+instance IsElement SVGCircleElement
+instance IsNode SVGCircleElement
+instance IsEventTarget SVGCircleElement
+instance IsGObject SVGCircleElement where
+  typeGType _ = gTypeSVGCircleElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SVGCircleElement\"]" gTypeSVGCircleElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SVGClipPathElement".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.SVGGraphicsElement"
+--     * "GHCJS.DOM.SVGElement"
+--     * "GHCJS.DOM.Element"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SVGClipPathElement Mozilla SVGClipPathElement documentation>
+newtype SVGClipPathElement = SVGClipPathElement { unSVGClipPathElement :: JSVal }
+
+instance Eq (SVGClipPathElement) where
+  (SVGClipPathElement a) == (SVGClipPathElement b) = js_eq a b
+
+instance PToJSVal SVGClipPathElement where
+  pToJSVal = unSVGClipPathElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SVGClipPathElement where
+  pFromJSVal = SVGClipPathElement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SVGClipPathElement where
+  toJSVal = return . unSVGClipPathElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SVGClipPathElement where
+  fromJSVal = return . fmap SVGClipPathElement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsSVGGraphicsElement SVGClipPathElement
+instance IsSVGElement SVGClipPathElement
+instance IsElement SVGClipPathElement
+instance IsNode SVGClipPathElement
+instance IsEventTarget SVGClipPathElement
+instance IsGObject SVGClipPathElement where
+  typeGType _ = gTypeSVGClipPathElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SVGClipPathElement\"]" gTypeSVGClipPathElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SVGColor".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.CSSValue"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SVGColor Mozilla SVGColor documentation>
+newtype SVGColor = SVGColor { unSVGColor :: JSVal }
+
+instance Eq (SVGColor) where
+  (SVGColor a) == (SVGColor b) = js_eq a b
+
+instance PToJSVal SVGColor where
+  pToJSVal = unSVGColor
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SVGColor where
+  pFromJSVal = SVGColor
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SVGColor where
+  toJSVal = return . unSVGColor
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SVGColor where
+  fromJSVal = return . fmap SVGColor . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+class IsCSSValue o => IsSVGColor o
+toSVGColor :: IsSVGColor o => o -> SVGColor
+toSVGColor = SVGColor . coerce
+
+instance IsSVGColor SVGColor
+instance IsCSSValue SVGColor
+instance IsGObject SVGColor where
+  typeGType _ = gTypeSVGColor
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SVGColor\"]" gTypeSVGColor :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SVGComponentTransferFunctionElement".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.SVGElement"
+--     * "GHCJS.DOM.Element"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SVGComponentTransferFunctionElement Mozilla SVGComponentTransferFunctionElement documentation>
+newtype SVGComponentTransferFunctionElement = SVGComponentTransferFunctionElement { unSVGComponentTransferFunctionElement :: JSVal }
+
+instance Eq (SVGComponentTransferFunctionElement) where
+  (SVGComponentTransferFunctionElement a) == (SVGComponentTransferFunctionElement b) = js_eq a b
+
+instance PToJSVal SVGComponentTransferFunctionElement where
+  pToJSVal = unSVGComponentTransferFunctionElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SVGComponentTransferFunctionElement where
+  pFromJSVal = SVGComponentTransferFunctionElement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SVGComponentTransferFunctionElement where
+  toJSVal = return . unSVGComponentTransferFunctionElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SVGComponentTransferFunctionElement where
+  fromJSVal = return . fmap SVGComponentTransferFunctionElement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+class IsSVGElement o => IsSVGComponentTransferFunctionElement o
+toSVGComponentTransferFunctionElement :: IsSVGComponentTransferFunctionElement o => o -> SVGComponentTransferFunctionElement
+toSVGComponentTransferFunctionElement = SVGComponentTransferFunctionElement . coerce
+
+instance IsSVGComponentTransferFunctionElement SVGComponentTransferFunctionElement
+instance IsSVGElement SVGComponentTransferFunctionElement
+instance IsElement SVGComponentTransferFunctionElement
+instance IsNode SVGComponentTransferFunctionElement
+instance IsEventTarget SVGComponentTransferFunctionElement
+instance IsGObject SVGComponentTransferFunctionElement where
+  typeGType _ = gTypeSVGComponentTransferFunctionElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SVGComponentTransferFunctionElement\"]" gTypeSVGComponentTransferFunctionElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SVGCursorElement".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.SVGElement"
+--     * "GHCJS.DOM.Element"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SVGCursorElement Mozilla SVGCursorElement documentation>
+newtype SVGCursorElement = SVGCursorElement { unSVGCursorElement :: JSVal }
+
+instance Eq (SVGCursorElement) where
+  (SVGCursorElement a) == (SVGCursorElement b) = js_eq a b
+
+instance PToJSVal SVGCursorElement where
+  pToJSVal = unSVGCursorElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SVGCursorElement where
+  pFromJSVal = SVGCursorElement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SVGCursorElement where
+  toJSVal = return . unSVGCursorElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SVGCursorElement where
+  fromJSVal = return . fmap SVGCursorElement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsSVGElement SVGCursorElement
+instance IsElement SVGCursorElement
+instance IsNode SVGCursorElement
+instance IsEventTarget SVGCursorElement
+instance IsGObject SVGCursorElement where
+  typeGType _ = gTypeSVGCursorElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SVGCursorElement\"]" gTypeSVGCursorElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SVGDefsElement".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.SVGGraphicsElement"
+--     * "GHCJS.DOM.SVGElement"
+--     * "GHCJS.DOM.Element"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SVGDefsElement Mozilla SVGDefsElement documentation>
+newtype SVGDefsElement = SVGDefsElement { unSVGDefsElement :: JSVal }
+
+instance Eq (SVGDefsElement) where
+  (SVGDefsElement a) == (SVGDefsElement b) = js_eq a b
+
+instance PToJSVal SVGDefsElement where
+  pToJSVal = unSVGDefsElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SVGDefsElement where
+  pFromJSVal = SVGDefsElement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SVGDefsElement where
+  toJSVal = return . unSVGDefsElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SVGDefsElement where
+  fromJSVal = return . fmap SVGDefsElement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsSVGGraphicsElement SVGDefsElement
+instance IsSVGElement SVGDefsElement
+instance IsElement SVGDefsElement
+instance IsNode SVGDefsElement
+instance IsEventTarget SVGDefsElement
+instance IsGObject SVGDefsElement where
+  typeGType _ = gTypeSVGDefsElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SVGDefsElement\"]" gTypeSVGDefsElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SVGDescElement".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.SVGElement"
+--     * "GHCJS.DOM.Element"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SVGDescElement Mozilla SVGDescElement documentation>
+newtype SVGDescElement = SVGDescElement { unSVGDescElement :: JSVal }
+
+instance Eq (SVGDescElement) where
+  (SVGDescElement a) == (SVGDescElement b) = js_eq a b
+
+instance PToJSVal SVGDescElement where
+  pToJSVal = unSVGDescElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SVGDescElement where
+  pFromJSVal = SVGDescElement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SVGDescElement where
+  toJSVal = return . unSVGDescElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SVGDescElement where
+  fromJSVal = return . fmap SVGDescElement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsSVGElement SVGDescElement
+instance IsElement SVGDescElement
+instance IsNode SVGDescElement
+instance IsEventTarget SVGDescElement
+instance IsGObject SVGDescElement where
+  typeGType _ = gTypeSVGDescElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SVGDescElement\"]" gTypeSVGDescElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SVGDocument".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.Document"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SVGDocument Mozilla SVGDocument documentation>
+newtype SVGDocument = SVGDocument { unSVGDocument :: JSVal }
+
+instance Eq (SVGDocument) where
+  (SVGDocument a) == (SVGDocument b) = js_eq a b
+
+instance PToJSVal SVGDocument where
+  pToJSVal = unSVGDocument
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SVGDocument where
+  pFromJSVal = SVGDocument
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SVGDocument where
+  toJSVal = return . unSVGDocument
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SVGDocument where
+  fromJSVal = return . fmap SVGDocument . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsDocument SVGDocument
+instance IsNode SVGDocument
+instance IsEventTarget SVGDocument
+instance IsGObject SVGDocument where
+  typeGType _ = gTypeSVGDocument
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SVGDocument\"]" gTypeSVGDocument :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SVGElement".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.Element"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SVGElement Mozilla SVGElement documentation>
+newtype SVGElement = SVGElement { unSVGElement :: JSVal }
+
+instance Eq (SVGElement) where
+  (SVGElement a) == (SVGElement b) = js_eq a b
+
+instance PToJSVal SVGElement where
+  pToJSVal = unSVGElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SVGElement where
+  pFromJSVal = SVGElement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SVGElement where
+  toJSVal = return . unSVGElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SVGElement where
+  fromJSVal = return . fmap SVGElement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+class IsElement o => IsSVGElement o
+toSVGElement :: IsSVGElement o => o -> SVGElement
+toSVGElement = SVGElement . coerce
+
+instance IsSVGElement SVGElement
+instance IsElement SVGElement
+instance IsNode SVGElement
+instance IsEventTarget SVGElement
+instance IsGObject SVGElement where
+  typeGType _ = gTypeSVGElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SVGElement\"]" gTypeSVGElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SVGEllipseElement".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.SVGGraphicsElement"
+--     * "GHCJS.DOM.SVGElement"
+--     * "GHCJS.DOM.Element"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SVGEllipseElement Mozilla SVGEllipseElement documentation>
+newtype SVGEllipseElement = SVGEllipseElement { unSVGEllipseElement :: JSVal }
+
+instance Eq (SVGEllipseElement) where
+  (SVGEllipseElement a) == (SVGEllipseElement b) = js_eq a b
+
+instance PToJSVal SVGEllipseElement where
+  pToJSVal = unSVGEllipseElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SVGEllipseElement where
+  pFromJSVal = SVGEllipseElement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SVGEllipseElement where
+  toJSVal = return . unSVGEllipseElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SVGEllipseElement where
+  fromJSVal = return . fmap SVGEllipseElement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsSVGGraphicsElement SVGEllipseElement
+instance IsSVGElement SVGEllipseElement
+instance IsElement SVGEllipseElement
+instance IsNode SVGEllipseElement
+instance IsEventTarget SVGEllipseElement
+instance IsGObject SVGEllipseElement where
+  typeGType _ = gTypeSVGEllipseElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SVGEllipseElement\"]" gTypeSVGEllipseElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SVGExternalResourcesRequired".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SVGExternalResourcesRequired Mozilla SVGExternalResourcesRequired documentation>
+newtype SVGExternalResourcesRequired = SVGExternalResourcesRequired { unSVGExternalResourcesRequired :: JSVal }
+
+instance Eq (SVGExternalResourcesRequired) where
+  (SVGExternalResourcesRequired a) == (SVGExternalResourcesRequired b) = js_eq a b
+
+instance PToJSVal SVGExternalResourcesRequired where
+  pToJSVal = unSVGExternalResourcesRequired
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SVGExternalResourcesRequired where
+  pFromJSVal = SVGExternalResourcesRequired
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SVGExternalResourcesRequired where
+  toJSVal = return . unSVGExternalResourcesRequired
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SVGExternalResourcesRequired where
+  fromJSVal = return . fmap SVGExternalResourcesRequired . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject SVGExternalResourcesRequired where
+  typeGType _ = gTypeSVGExternalResourcesRequired
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SVGExternalResourcesRequired\"]" gTypeSVGExternalResourcesRequired :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SVGFEBlendElement".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.SVGElement"
+--     * "GHCJS.DOM.Element"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SVGFEBlendElement Mozilla SVGFEBlendElement documentation>
+newtype SVGFEBlendElement = SVGFEBlendElement { unSVGFEBlendElement :: JSVal }
+
+instance Eq (SVGFEBlendElement) where
+  (SVGFEBlendElement a) == (SVGFEBlendElement b) = js_eq a b
+
+instance PToJSVal SVGFEBlendElement where
+  pToJSVal = unSVGFEBlendElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SVGFEBlendElement where
+  pFromJSVal = SVGFEBlendElement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SVGFEBlendElement where
+  toJSVal = return . unSVGFEBlendElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SVGFEBlendElement where
+  fromJSVal = return . fmap SVGFEBlendElement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsSVGElement SVGFEBlendElement
+instance IsElement SVGFEBlendElement
+instance IsNode SVGFEBlendElement
+instance IsEventTarget SVGFEBlendElement
+instance IsGObject SVGFEBlendElement where
+  typeGType _ = gTypeSVGFEBlendElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SVGFEBlendElement\"]" gTypeSVGFEBlendElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SVGFEColorMatrixElement".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.SVGElement"
+--     * "GHCJS.DOM.Element"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SVGFEColorMatrixElement Mozilla SVGFEColorMatrixElement documentation>
+newtype SVGFEColorMatrixElement = SVGFEColorMatrixElement { unSVGFEColorMatrixElement :: JSVal }
+
+instance Eq (SVGFEColorMatrixElement) where
+  (SVGFEColorMatrixElement a) == (SVGFEColorMatrixElement b) = js_eq a b
+
+instance PToJSVal SVGFEColorMatrixElement where
+  pToJSVal = unSVGFEColorMatrixElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SVGFEColorMatrixElement where
+  pFromJSVal = SVGFEColorMatrixElement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SVGFEColorMatrixElement where
+  toJSVal = return . unSVGFEColorMatrixElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SVGFEColorMatrixElement where
+  fromJSVal = return . fmap SVGFEColorMatrixElement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsSVGElement SVGFEColorMatrixElement
+instance IsElement SVGFEColorMatrixElement
+instance IsNode SVGFEColorMatrixElement
+instance IsEventTarget SVGFEColorMatrixElement
+instance IsGObject SVGFEColorMatrixElement where
+  typeGType _ = gTypeSVGFEColorMatrixElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SVGFEColorMatrixElement\"]" gTypeSVGFEColorMatrixElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SVGFEComponentTransferElement".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.SVGElement"
+--     * "GHCJS.DOM.Element"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SVGFEComponentTransferElement Mozilla SVGFEComponentTransferElement documentation>
+newtype SVGFEComponentTransferElement = SVGFEComponentTransferElement { unSVGFEComponentTransferElement :: JSVal }
+
+instance Eq (SVGFEComponentTransferElement) where
+  (SVGFEComponentTransferElement a) == (SVGFEComponentTransferElement b) = js_eq a b
+
+instance PToJSVal SVGFEComponentTransferElement where
+  pToJSVal = unSVGFEComponentTransferElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SVGFEComponentTransferElement where
+  pFromJSVal = SVGFEComponentTransferElement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SVGFEComponentTransferElement where
+  toJSVal = return . unSVGFEComponentTransferElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SVGFEComponentTransferElement where
+  fromJSVal = return . fmap SVGFEComponentTransferElement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsSVGElement SVGFEComponentTransferElement
+instance IsElement SVGFEComponentTransferElement
+instance IsNode SVGFEComponentTransferElement
+instance IsEventTarget SVGFEComponentTransferElement
+instance IsGObject SVGFEComponentTransferElement where
+  typeGType _ = gTypeSVGFEComponentTransferElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SVGFEComponentTransferElement\"]" gTypeSVGFEComponentTransferElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SVGFECompositeElement".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.SVGElement"
+--     * "GHCJS.DOM.Element"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SVGFECompositeElement Mozilla SVGFECompositeElement documentation>
+newtype SVGFECompositeElement = SVGFECompositeElement { unSVGFECompositeElement :: JSVal }
+
+instance Eq (SVGFECompositeElement) where
+  (SVGFECompositeElement a) == (SVGFECompositeElement b) = js_eq a b
+
+instance PToJSVal SVGFECompositeElement where
+  pToJSVal = unSVGFECompositeElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SVGFECompositeElement where
+  pFromJSVal = SVGFECompositeElement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SVGFECompositeElement where
+  toJSVal = return . unSVGFECompositeElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SVGFECompositeElement where
+  fromJSVal = return . fmap SVGFECompositeElement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsSVGElement SVGFECompositeElement
+instance IsElement SVGFECompositeElement
+instance IsNode SVGFECompositeElement
+instance IsEventTarget SVGFECompositeElement
+instance IsGObject SVGFECompositeElement where
+  typeGType _ = gTypeSVGFECompositeElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SVGFECompositeElement\"]" gTypeSVGFECompositeElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SVGFEConvolveMatrixElement".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.SVGElement"
+--     * "GHCJS.DOM.Element"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SVGFEConvolveMatrixElement Mozilla SVGFEConvolveMatrixElement documentation>
+newtype SVGFEConvolveMatrixElement = SVGFEConvolveMatrixElement { unSVGFEConvolveMatrixElement :: JSVal }
+
+instance Eq (SVGFEConvolveMatrixElement) where
+  (SVGFEConvolveMatrixElement a) == (SVGFEConvolveMatrixElement b) = js_eq a b
+
+instance PToJSVal SVGFEConvolveMatrixElement where
+  pToJSVal = unSVGFEConvolveMatrixElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SVGFEConvolveMatrixElement where
+  pFromJSVal = SVGFEConvolveMatrixElement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SVGFEConvolveMatrixElement where
+  toJSVal = return . unSVGFEConvolveMatrixElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SVGFEConvolveMatrixElement where
+  fromJSVal = return . fmap SVGFEConvolveMatrixElement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsSVGElement SVGFEConvolveMatrixElement
+instance IsElement SVGFEConvolveMatrixElement
+instance IsNode SVGFEConvolveMatrixElement
+instance IsEventTarget SVGFEConvolveMatrixElement
+instance IsGObject SVGFEConvolveMatrixElement where
+  typeGType _ = gTypeSVGFEConvolveMatrixElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SVGFEConvolveMatrixElement\"]" gTypeSVGFEConvolveMatrixElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SVGFEDiffuseLightingElement".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.SVGElement"
+--     * "GHCJS.DOM.Element"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SVGFEDiffuseLightingElement Mozilla SVGFEDiffuseLightingElement documentation>
+newtype SVGFEDiffuseLightingElement = SVGFEDiffuseLightingElement { unSVGFEDiffuseLightingElement :: JSVal }
+
+instance Eq (SVGFEDiffuseLightingElement) where
+  (SVGFEDiffuseLightingElement a) == (SVGFEDiffuseLightingElement b) = js_eq a b
+
+instance PToJSVal SVGFEDiffuseLightingElement where
+  pToJSVal = unSVGFEDiffuseLightingElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SVGFEDiffuseLightingElement where
+  pFromJSVal = SVGFEDiffuseLightingElement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SVGFEDiffuseLightingElement where
+  toJSVal = return . unSVGFEDiffuseLightingElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SVGFEDiffuseLightingElement where
+  fromJSVal = return . fmap SVGFEDiffuseLightingElement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsSVGElement SVGFEDiffuseLightingElement
+instance IsElement SVGFEDiffuseLightingElement
+instance IsNode SVGFEDiffuseLightingElement
+instance IsEventTarget SVGFEDiffuseLightingElement
+instance IsGObject SVGFEDiffuseLightingElement where
+  typeGType _ = gTypeSVGFEDiffuseLightingElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SVGFEDiffuseLightingElement\"]" gTypeSVGFEDiffuseLightingElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SVGFEDisplacementMapElement".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.SVGElement"
+--     * "GHCJS.DOM.Element"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SVGFEDisplacementMapElement Mozilla SVGFEDisplacementMapElement documentation>
+newtype SVGFEDisplacementMapElement = SVGFEDisplacementMapElement { unSVGFEDisplacementMapElement :: JSVal }
+
+instance Eq (SVGFEDisplacementMapElement) where
+  (SVGFEDisplacementMapElement a) == (SVGFEDisplacementMapElement b) = js_eq a b
+
+instance PToJSVal SVGFEDisplacementMapElement where
+  pToJSVal = unSVGFEDisplacementMapElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SVGFEDisplacementMapElement where
+  pFromJSVal = SVGFEDisplacementMapElement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SVGFEDisplacementMapElement where
+  toJSVal = return . unSVGFEDisplacementMapElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SVGFEDisplacementMapElement where
+  fromJSVal = return . fmap SVGFEDisplacementMapElement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsSVGElement SVGFEDisplacementMapElement
+instance IsElement SVGFEDisplacementMapElement
+instance IsNode SVGFEDisplacementMapElement
+instance IsEventTarget SVGFEDisplacementMapElement
+instance IsGObject SVGFEDisplacementMapElement where
+  typeGType _ = gTypeSVGFEDisplacementMapElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SVGFEDisplacementMapElement\"]" gTypeSVGFEDisplacementMapElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SVGFEDistantLightElement".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.SVGElement"
+--     * "GHCJS.DOM.Element"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SVGFEDistantLightElement Mozilla SVGFEDistantLightElement documentation>
+newtype SVGFEDistantLightElement = SVGFEDistantLightElement { unSVGFEDistantLightElement :: JSVal }
+
+instance Eq (SVGFEDistantLightElement) where
+  (SVGFEDistantLightElement a) == (SVGFEDistantLightElement b) = js_eq a b
+
+instance PToJSVal SVGFEDistantLightElement where
+  pToJSVal = unSVGFEDistantLightElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SVGFEDistantLightElement where
+  pFromJSVal = SVGFEDistantLightElement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SVGFEDistantLightElement where
+  toJSVal = return . unSVGFEDistantLightElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SVGFEDistantLightElement where
+  fromJSVal = return . fmap SVGFEDistantLightElement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsSVGElement SVGFEDistantLightElement
+instance IsElement SVGFEDistantLightElement
+instance IsNode SVGFEDistantLightElement
+instance IsEventTarget SVGFEDistantLightElement
+instance IsGObject SVGFEDistantLightElement where
+  typeGType _ = gTypeSVGFEDistantLightElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SVGFEDistantLightElement\"]" gTypeSVGFEDistantLightElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SVGFEDropShadowElement".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.SVGElement"
+--     * "GHCJS.DOM.Element"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SVGFEDropShadowElement Mozilla SVGFEDropShadowElement documentation>
+newtype SVGFEDropShadowElement = SVGFEDropShadowElement { unSVGFEDropShadowElement :: JSVal }
+
+instance Eq (SVGFEDropShadowElement) where
+  (SVGFEDropShadowElement a) == (SVGFEDropShadowElement b) = js_eq a b
+
+instance PToJSVal SVGFEDropShadowElement where
+  pToJSVal = unSVGFEDropShadowElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SVGFEDropShadowElement where
+  pFromJSVal = SVGFEDropShadowElement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SVGFEDropShadowElement where
+  toJSVal = return . unSVGFEDropShadowElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SVGFEDropShadowElement where
+  fromJSVal = return . fmap SVGFEDropShadowElement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsSVGElement SVGFEDropShadowElement
+instance IsElement SVGFEDropShadowElement
+instance IsNode SVGFEDropShadowElement
+instance IsEventTarget SVGFEDropShadowElement
+instance IsGObject SVGFEDropShadowElement where
+  typeGType _ = gTypeSVGFEDropShadowElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SVGFEDropShadowElement\"]" gTypeSVGFEDropShadowElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SVGFEFloodElement".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.SVGElement"
+--     * "GHCJS.DOM.Element"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SVGFEFloodElement Mozilla SVGFEFloodElement documentation>
+newtype SVGFEFloodElement = SVGFEFloodElement { unSVGFEFloodElement :: JSVal }
+
+instance Eq (SVGFEFloodElement) where
+  (SVGFEFloodElement a) == (SVGFEFloodElement b) = js_eq a b
+
+instance PToJSVal SVGFEFloodElement where
+  pToJSVal = unSVGFEFloodElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SVGFEFloodElement where
+  pFromJSVal = SVGFEFloodElement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SVGFEFloodElement where
+  toJSVal = return . unSVGFEFloodElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SVGFEFloodElement where
+  fromJSVal = return . fmap SVGFEFloodElement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsSVGElement SVGFEFloodElement
+instance IsElement SVGFEFloodElement
+instance IsNode SVGFEFloodElement
+instance IsEventTarget SVGFEFloodElement
+instance IsGObject SVGFEFloodElement where
+  typeGType _ = gTypeSVGFEFloodElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SVGFEFloodElement\"]" gTypeSVGFEFloodElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SVGFEFuncAElement".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.SVGComponentTransferFunctionElement"
+--     * "GHCJS.DOM.SVGElement"
+--     * "GHCJS.DOM.Element"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SVGFEFuncAElement Mozilla SVGFEFuncAElement documentation>
+newtype SVGFEFuncAElement = SVGFEFuncAElement { unSVGFEFuncAElement :: JSVal }
+
+instance Eq (SVGFEFuncAElement) where
+  (SVGFEFuncAElement a) == (SVGFEFuncAElement b) = js_eq a b
+
+instance PToJSVal SVGFEFuncAElement where
+  pToJSVal = unSVGFEFuncAElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SVGFEFuncAElement where
+  pFromJSVal = SVGFEFuncAElement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SVGFEFuncAElement where
+  toJSVal = return . unSVGFEFuncAElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SVGFEFuncAElement where
+  fromJSVal = return . fmap SVGFEFuncAElement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsSVGComponentTransferFunctionElement SVGFEFuncAElement
+instance IsSVGElement SVGFEFuncAElement
+instance IsElement SVGFEFuncAElement
+instance IsNode SVGFEFuncAElement
+instance IsEventTarget SVGFEFuncAElement
+instance IsGObject SVGFEFuncAElement where
+  typeGType _ = gTypeSVGFEFuncAElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SVGFEFuncAElement\"]" gTypeSVGFEFuncAElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SVGFEFuncBElement".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.SVGComponentTransferFunctionElement"
+--     * "GHCJS.DOM.SVGElement"
+--     * "GHCJS.DOM.Element"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SVGFEFuncBElement Mozilla SVGFEFuncBElement documentation>
+newtype SVGFEFuncBElement = SVGFEFuncBElement { unSVGFEFuncBElement :: JSVal }
+
+instance Eq (SVGFEFuncBElement) where
+  (SVGFEFuncBElement a) == (SVGFEFuncBElement b) = js_eq a b
+
+instance PToJSVal SVGFEFuncBElement where
+  pToJSVal = unSVGFEFuncBElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SVGFEFuncBElement where
+  pFromJSVal = SVGFEFuncBElement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SVGFEFuncBElement where
+  toJSVal = return . unSVGFEFuncBElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SVGFEFuncBElement where
+  fromJSVal = return . fmap SVGFEFuncBElement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsSVGComponentTransferFunctionElement SVGFEFuncBElement
+instance IsSVGElement SVGFEFuncBElement
+instance IsElement SVGFEFuncBElement
+instance IsNode SVGFEFuncBElement
+instance IsEventTarget SVGFEFuncBElement
+instance IsGObject SVGFEFuncBElement where
+  typeGType _ = gTypeSVGFEFuncBElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SVGFEFuncBElement\"]" gTypeSVGFEFuncBElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SVGFEFuncGElement".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.SVGComponentTransferFunctionElement"
+--     * "GHCJS.DOM.SVGElement"
+--     * "GHCJS.DOM.Element"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SVGFEFuncGElement Mozilla SVGFEFuncGElement documentation>
+newtype SVGFEFuncGElement = SVGFEFuncGElement { unSVGFEFuncGElement :: JSVal }
+
+instance Eq (SVGFEFuncGElement) where
+  (SVGFEFuncGElement a) == (SVGFEFuncGElement b) = js_eq a b
+
+instance PToJSVal SVGFEFuncGElement where
+  pToJSVal = unSVGFEFuncGElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SVGFEFuncGElement where
+  pFromJSVal = SVGFEFuncGElement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SVGFEFuncGElement where
+  toJSVal = return . unSVGFEFuncGElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SVGFEFuncGElement where
+  fromJSVal = return . fmap SVGFEFuncGElement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsSVGComponentTransferFunctionElement SVGFEFuncGElement
+instance IsSVGElement SVGFEFuncGElement
+instance IsElement SVGFEFuncGElement
+instance IsNode SVGFEFuncGElement
+instance IsEventTarget SVGFEFuncGElement
+instance IsGObject SVGFEFuncGElement where
+  typeGType _ = gTypeSVGFEFuncGElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SVGFEFuncGElement\"]" gTypeSVGFEFuncGElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SVGFEFuncRElement".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.SVGComponentTransferFunctionElement"
+--     * "GHCJS.DOM.SVGElement"
+--     * "GHCJS.DOM.Element"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SVGFEFuncRElement Mozilla SVGFEFuncRElement documentation>
+newtype SVGFEFuncRElement = SVGFEFuncRElement { unSVGFEFuncRElement :: JSVal }
+
+instance Eq (SVGFEFuncRElement) where
+  (SVGFEFuncRElement a) == (SVGFEFuncRElement b) = js_eq a b
+
+instance PToJSVal SVGFEFuncRElement where
+  pToJSVal = unSVGFEFuncRElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SVGFEFuncRElement where
+  pFromJSVal = SVGFEFuncRElement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SVGFEFuncRElement where
+  toJSVal = return . unSVGFEFuncRElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SVGFEFuncRElement where
+  fromJSVal = return . fmap SVGFEFuncRElement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsSVGComponentTransferFunctionElement SVGFEFuncRElement
+instance IsSVGElement SVGFEFuncRElement
+instance IsElement SVGFEFuncRElement
+instance IsNode SVGFEFuncRElement
+instance IsEventTarget SVGFEFuncRElement
+instance IsGObject SVGFEFuncRElement where
+  typeGType _ = gTypeSVGFEFuncRElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SVGFEFuncRElement\"]" gTypeSVGFEFuncRElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SVGFEGaussianBlurElement".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.SVGElement"
+--     * "GHCJS.DOM.Element"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SVGFEGaussianBlurElement Mozilla SVGFEGaussianBlurElement documentation>
+newtype SVGFEGaussianBlurElement = SVGFEGaussianBlurElement { unSVGFEGaussianBlurElement :: JSVal }
+
+instance Eq (SVGFEGaussianBlurElement) where
+  (SVGFEGaussianBlurElement a) == (SVGFEGaussianBlurElement b) = js_eq a b
+
+instance PToJSVal SVGFEGaussianBlurElement where
+  pToJSVal = unSVGFEGaussianBlurElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SVGFEGaussianBlurElement where
+  pFromJSVal = SVGFEGaussianBlurElement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SVGFEGaussianBlurElement where
+  toJSVal = return . unSVGFEGaussianBlurElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SVGFEGaussianBlurElement where
+  fromJSVal = return . fmap SVGFEGaussianBlurElement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsSVGElement SVGFEGaussianBlurElement
+instance IsElement SVGFEGaussianBlurElement
+instance IsNode SVGFEGaussianBlurElement
+instance IsEventTarget SVGFEGaussianBlurElement
+instance IsGObject SVGFEGaussianBlurElement where
+  typeGType _ = gTypeSVGFEGaussianBlurElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SVGFEGaussianBlurElement\"]" gTypeSVGFEGaussianBlurElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SVGFEImageElement".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.SVGElement"
+--     * "GHCJS.DOM.Element"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SVGFEImageElement Mozilla SVGFEImageElement documentation>
+newtype SVGFEImageElement = SVGFEImageElement { unSVGFEImageElement :: JSVal }
+
+instance Eq (SVGFEImageElement) where
+  (SVGFEImageElement a) == (SVGFEImageElement b) = js_eq a b
+
+instance PToJSVal SVGFEImageElement where
+  pToJSVal = unSVGFEImageElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SVGFEImageElement where
+  pFromJSVal = SVGFEImageElement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SVGFEImageElement where
+  toJSVal = return . unSVGFEImageElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SVGFEImageElement where
+  fromJSVal = return . fmap SVGFEImageElement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsSVGElement SVGFEImageElement
+instance IsElement SVGFEImageElement
+instance IsNode SVGFEImageElement
+instance IsEventTarget SVGFEImageElement
+instance IsGObject SVGFEImageElement where
+  typeGType _ = gTypeSVGFEImageElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SVGFEImageElement\"]" gTypeSVGFEImageElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SVGFEMergeElement".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.SVGElement"
+--     * "GHCJS.DOM.Element"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SVGFEMergeElement Mozilla SVGFEMergeElement documentation>
+newtype SVGFEMergeElement = SVGFEMergeElement { unSVGFEMergeElement :: JSVal }
+
+instance Eq (SVGFEMergeElement) where
+  (SVGFEMergeElement a) == (SVGFEMergeElement b) = js_eq a b
+
+instance PToJSVal SVGFEMergeElement where
+  pToJSVal = unSVGFEMergeElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SVGFEMergeElement where
+  pFromJSVal = SVGFEMergeElement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SVGFEMergeElement where
+  toJSVal = return . unSVGFEMergeElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SVGFEMergeElement where
+  fromJSVal = return . fmap SVGFEMergeElement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsSVGElement SVGFEMergeElement
+instance IsElement SVGFEMergeElement
+instance IsNode SVGFEMergeElement
+instance IsEventTarget SVGFEMergeElement
+instance IsGObject SVGFEMergeElement where
+  typeGType _ = gTypeSVGFEMergeElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SVGFEMergeElement\"]" gTypeSVGFEMergeElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SVGFEMergeNodeElement".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.SVGElement"
+--     * "GHCJS.DOM.Element"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SVGFEMergeNodeElement Mozilla SVGFEMergeNodeElement documentation>
+newtype SVGFEMergeNodeElement = SVGFEMergeNodeElement { unSVGFEMergeNodeElement :: JSVal }
+
+instance Eq (SVGFEMergeNodeElement) where
+  (SVGFEMergeNodeElement a) == (SVGFEMergeNodeElement b) = js_eq a b
+
+instance PToJSVal SVGFEMergeNodeElement where
+  pToJSVal = unSVGFEMergeNodeElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SVGFEMergeNodeElement where
+  pFromJSVal = SVGFEMergeNodeElement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SVGFEMergeNodeElement where
+  toJSVal = return . unSVGFEMergeNodeElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SVGFEMergeNodeElement where
+  fromJSVal = return . fmap SVGFEMergeNodeElement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsSVGElement SVGFEMergeNodeElement
+instance IsElement SVGFEMergeNodeElement
+instance IsNode SVGFEMergeNodeElement
+instance IsEventTarget SVGFEMergeNodeElement
+instance IsGObject SVGFEMergeNodeElement where
+  typeGType _ = gTypeSVGFEMergeNodeElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SVGFEMergeNodeElement\"]" gTypeSVGFEMergeNodeElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SVGFEMorphologyElement".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.SVGElement"
+--     * "GHCJS.DOM.Element"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SVGFEMorphologyElement Mozilla SVGFEMorphologyElement documentation>
+newtype SVGFEMorphologyElement = SVGFEMorphologyElement { unSVGFEMorphologyElement :: JSVal }
+
+instance Eq (SVGFEMorphologyElement) where
+  (SVGFEMorphologyElement a) == (SVGFEMorphologyElement b) = js_eq a b
+
+instance PToJSVal SVGFEMorphologyElement where
+  pToJSVal = unSVGFEMorphologyElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SVGFEMorphologyElement where
+  pFromJSVal = SVGFEMorphologyElement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SVGFEMorphologyElement where
+  toJSVal = return . unSVGFEMorphologyElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SVGFEMorphologyElement where
+  fromJSVal = return . fmap SVGFEMorphologyElement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsSVGElement SVGFEMorphologyElement
+instance IsElement SVGFEMorphologyElement
+instance IsNode SVGFEMorphologyElement
+instance IsEventTarget SVGFEMorphologyElement
+instance IsGObject SVGFEMorphologyElement where
+  typeGType _ = gTypeSVGFEMorphologyElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SVGFEMorphologyElement\"]" gTypeSVGFEMorphologyElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SVGFEOffsetElement".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.SVGElement"
+--     * "GHCJS.DOM.Element"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SVGFEOffsetElement Mozilla SVGFEOffsetElement documentation>
+newtype SVGFEOffsetElement = SVGFEOffsetElement { unSVGFEOffsetElement :: JSVal }
+
+instance Eq (SVGFEOffsetElement) where
+  (SVGFEOffsetElement a) == (SVGFEOffsetElement b) = js_eq a b
+
+instance PToJSVal SVGFEOffsetElement where
+  pToJSVal = unSVGFEOffsetElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SVGFEOffsetElement where
+  pFromJSVal = SVGFEOffsetElement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SVGFEOffsetElement where
+  toJSVal = return . unSVGFEOffsetElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SVGFEOffsetElement where
+  fromJSVal = return . fmap SVGFEOffsetElement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsSVGElement SVGFEOffsetElement
+instance IsElement SVGFEOffsetElement
+instance IsNode SVGFEOffsetElement
+instance IsEventTarget SVGFEOffsetElement
+instance IsGObject SVGFEOffsetElement where
+  typeGType _ = gTypeSVGFEOffsetElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SVGFEOffsetElement\"]" gTypeSVGFEOffsetElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SVGFEPointLightElement".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.SVGElement"
+--     * "GHCJS.DOM.Element"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SVGFEPointLightElement Mozilla SVGFEPointLightElement documentation>
+newtype SVGFEPointLightElement = SVGFEPointLightElement { unSVGFEPointLightElement :: JSVal }
+
+instance Eq (SVGFEPointLightElement) where
+  (SVGFEPointLightElement a) == (SVGFEPointLightElement b) = js_eq a b
+
+instance PToJSVal SVGFEPointLightElement where
+  pToJSVal = unSVGFEPointLightElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SVGFEPointLightElement where
+  pFromJSVal = SVGFEPointLightElement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SVGFEPointLightElement where
+  toJSVal = return . unSVGFEPointLightElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SVGFEPointLightElement where
+  fromJSVal = return . fmap SVGFEPointLightElement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsSVGElement SVGFEPointLightElement
+instance IsElement SVGFEPointLightElement
+instance IsNode SVGFEPointLightElement
+instance IsEventTarget SVGFEPointLightElement
+instance IsGObject SVGFEPointLightElement where
+  typeGType _ = gTypeSVGFEPointLightElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SVGFEPointLightElement\"]" gTypeSVGFEPointLightElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SVGFESpecularLightingElement".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.SVGElement"
+--     * "GHCJS.DOM.Element"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SVGFESpecularLightingElement Mozilla SVGFESpecularLightingElement documentation>
+newtype SVGFESpecularLightingElement = SVGFESpecularLightingElement { unSVGFESpecularLightingElement :: JSVal }
+
+instance Eq (SVGFESpecularLightingElement) where
+  (SVGFESpecularLightingElement a) == (SVGFESpecularLightingElement b) = js_eq a b
+
+instance PToJSVal SVGFESpecularLightingElement where
+  pToJSVal = unSVGFESpecularLightingElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SVGFESpecularLightingElement where
+  pFromJSVal = SVGFESpecularLightingElement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SVGFESpecularLightingElement where
+  toJSVal = return . unSVGFESpecularLightingElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SVGFESpecularLightingElement where
+  fromJSVal = return . fmap SVGFESpecularLightingElement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsSVGElement SVGFESpecularLightingElement
+instance IsElement SVGFESpecularLightingElement
+instance IsNode SVGFESpecularLightingElement
+instance IsEventTarget SVGFESpecularLightingElement
+instance IsGObject SVGFESpecularLightingElement where
+  typeGType _ = gTypeSVGFESpecularLightingElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SVGFESpecularLightingElement\"]" gTypeSVGFESpecularLightingElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SVGFESpotLightElement".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.SVGElement"
+--     * "GHCJS.DOM.Element"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SVGFESpotLightElement Mozilla SVGFESpotLightElement documentation>
+newtype SVGFESpotLightElement = SVGFESpotLightElement { unSVGFESpotLightElement :: JSVal }
+
+instance Eq (SVGFESpotLightElement) where
+  (SVGFESpotLightElement a) == (SVGFESpotLightElement b) = js_eq a b
+
+instance PToJSVal SVGFESpotLightElement where
+  pToJSVal = unSVGFESpotLightElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SVGFESpotLightElement where
+  pFromJSVal = SVGFESpotLightElement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SVGFESpotLightElement where
+  toJSVal = return . unSVGFESpotLightElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SVGFESpotLightElement where
+  fromJSVal = return . fmap SVGFESpotLightElement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsSVGElement SVGFESpotLightElement
+instance IsElement SVGFESpotLightElement
+instance IsNode SVGFESpotLightElement
+instance IsEventTarget SVGFESpotLightElement
+instance IsGObject SVGFESpotLightElement where
+  typeGType _ = gTypeSVGFESpotLightElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SVGFESpotLightElement\"]" gTypeSVGFESpotLightElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SVGFETileElement".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.SVGElement"
+--     * "GHCJS.DOM.Element"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SVGFETileElement Mozilla SVGFETileElement documentation>
+newtype SVGFETileElement = SVGFETileElement { unSVGFETileElement :: JSVal }
+
+instance Eq (SVGFETileElement) where
+  (SVGFETileElement a) == (SVGFETileElement b) = js_eq a b
+
+instance PToJSVal SVGFETileElement where
+  pToJSVal = unSVGFETileElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SVGFETileElement where
+  pFromJSVal = SVGFETileElement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SVGFETileElement where
+  toJSVal = return . unSVGFETileElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SVGFETileElement where
+  fromJSVal = return . fmap SVGFETileElement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsSVGElement SVGFETileElement
+instance IsElement SVGFETileElement
+instance IsNode SVGFETileElement
+instance IsEventTarget SVGFETileElement
+instance IsGObject SVGFETileElement where
+  typeGType _ = gTypeSVGFETileElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SVGFETileElement\"]" gTypeSVGFETileElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SVGFETurbulenceElement".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.SVGElement"
+--     * "GHCJS.DOM.Element"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SVGFETurbulenceElement Mozilla SVGFETurbulenceElement documentation>
+newtype SVGFETurbulenceElement = SVGFETurbulenceElement { unSVGFETurbulenceElement :: JSVal }
+
+instance Eq (SVGFETurbulenceElement) where
+  (SVGFETurbulenceElement a) == (SVGFETurbulenceElement b) = js_eq a b
+
+instance PToJSVal SVGFETurbulenceElement where
+  pToJSVal = unSVGFETurbulenceElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SVGFETurbulenceElement where
+  pFromJSVal = SVGFETurbulenceElement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SVGFETurbulenceElement where
+  toJSVal = return . unSVGFETurbulenceElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SVGFETurbulenceElement where
+  fromJSVal = return . fmap SVGFETurbulenceElement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsSVGElement SVGFETurbulenceElement
+instance IsElement SVGFETurbulenceElement
+instance IsNode SVGFETurbulenceElement
+instance IsEventTarget SVGFETurbulenceElement
+instance IsGObject SVGFETurbulenceElement where
+  typeGType _ = gTypeSVGFETurbulenceElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SVGFETurbulenceElement\"]" gTypeSVGFETurbulenceElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SVGFilterElement".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.SVGElement"
+--     * "GHCJS.DOM.Element"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SVGFilterElement Mozilla SVGFilterElement documentation>
+newtype SVGFilterElement = SVGFilterElement { unSVGFilterElement :: JSVal }
+
+instance Eq (SVGFilterElement) where
+  (SVGFilterElement a) == (SVGFilterElement b) = js_eq a b
+
+instance PToJSVal SVGFilterElement where
+  pToJSVal = unSVGFilterElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SVGFilterElement where
+  pFromJSVal = SVGFilterElement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SVGFilterElement where
+  toJSVal = return . unSVGFilterElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SVGFilterElement where
+  fromJSVal = return . fmap SVGFilterElement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsSVGElement SVGFilterElement
+instance IsElement SVGFilterElement
+instance IsNode SVGFilterElement
+instance IsEventTarget SVGFilterElement
+instance IsGObject SVGFilterElement where
+  typeGType _ = gTypeSVGFilterElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SVGFilterElement\"]" gTypeSVGFilterElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SVGFilterPrimitiveStandardAttributes".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SVGFilterPrimitiveStandardAttributes Mozilla SVGFilterPrimitiveStandardAttributes documentation>
+newtype SVGFilterPrimitiveStandardAttributes = SVGFilterPrimitiveStandardAttributes { unSVGFilterPrimitiveStandardAttributes :: JSVal }
+
+instance Eq (SVGFilterPrimitiveStandardAttributes) where
+  (SVGFilterPrimitiveStandardAttributes a) == (SVGFilterPrimitiveStandardAttributes b) = js_eq a b
+
+instance PToJSVal SVGFilterPrimitiveStandardAttributes where
+  pToJSVal = unSVGFilterPrimitiveStandardAttributes
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SVGFilterPrimitiveStandardAttributes where
+  pFromJSVal = SVGFilterPrimitiveStandardAttributes
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SVGFilterPrimitiveStandardAttributes where
+  toJSVal = return . unSVGFilterPrimitiveStandardAttributes
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SVGFilterPrimitiveStandardAttributes where
+  fromJSVal = return . fmap SVGFilterPrimitiveStandardAttributes . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject SVGFilterPrimitiveStandardAttributes where
+  typeGType _ = gTypeSVGFilterPrimitiveStandardAttributes
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SVGFilterPrimitiveStandardAttributes\"]" gTypeSVGFilterPrimitiveStandardAttributes :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SVGFitToViewBox".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SVGFitToViewBox Mozilla SVGFitToViewBox documentation>
+newtype SVGFitToViewBox = SVGFitToViewBox { unSVGFitToViewBox :: JSVal }
+
+instance Eq (SVGFitToViewBox) where
+  (SVGFitToViewBox a) == (SVGFitToViewBox b) = js_eq a b
+
+instance PToJSVal SVGFitToViewBox where
+  pToJSVal = unSVGFitToViewBox
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SVGFitToViewBox where
+  pFromJSVal = SVGFitToViewBox
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SVGFitToViewBox where
+  toJSVal = return . unSVGFitToViewBox
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SVGFitToViewBox where
+  fromJSVal = return . fmap SVGFitToViewBox . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject SVGFitToViewBox where
+  typeGType _ = gTypeSVGFitToViewBox
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SVGFitToViewBox\"]" gTypeSVGFitToViewBox :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SVGFontElement".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.SVGElement"
+--     * "GHCJS.DOM.Element"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SVGFontElement Mozilla SVGFontElement documentation>
+newtype SVGFontElement = SVGFontElement { unSVGFontElement :: JSVal }
+
+instance Eq (SVGFontElement) where
+  (SVGFontElement a) == (SVGFontElement b) = js_eq a b
+
+instance PToJSVal SVGFontElement where
+  pToJSVal = unSVGFontElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SVGFontElement where
+  pFromJSVal = SVGFontElement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SVGFontElement where
+  toJSVal = return . unSVGFontElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SVGFontElement where
+  fromJSVal = return . fmap SVGFontElement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsSVGElement SVGFontElement
+instance IsElement SVGFontElement
+instance IsNode SVGFontElement
+instance IsEventTarget SVGFontElement
+instance IsGObject SVGFontElement where
+  typeGType _ = gTypeSVGFontElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SVGFontElement\"]" gTypeSVGFontElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SVGFontFaceElement".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.SVGElement"
+--     * "GHCJS.DOM.Element"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SVGFontFaceElement Mozilla SVGFontFaceElement documentation>
+newtype SVGFontFaceElement = SVGFontFaceElement { unSVGFontFaceElement :: JSVal }
+
+instance Eq (SVGFontFaceElement) where
+  (SVGFontFaceElement a) == (SVGFontFaceElement b) = js_eq a b
+
+instance PToJSVal SVGFontFaceElement where
+  pToJSVal = unSVGFontFaceElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SVGFontFaceElement where
+  pFromJSVal = SVGFontFaceElement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SVGFontFaceElement where
+  toJSVal = return . unSVGFontFaceElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SVGFontFaceElement where
+  fromJSVal = return . fmap SVGFontFaceElement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsSVGElement SVGFontFaceElement
+instance IsElement SVGFontFaceElement
+instance IsNode SVGFontFaceElement
+instance IsEventTarget SVGFontFaceElement
+instance IsGObject SVGFontFaceElement where
+  typeGType _ = gTypeSVGFontFaceElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SVGFontFaceElement\"]" gTypeSVGFontFaceElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SVGFontFaceFormatElement".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.SVGElement"
+--     * "GHCJS.DOM.Element"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SVGFontFaceFormatElement Mozilla SVGFontFaceFormatElement documentation>
+newtype SVGFontFaceFormatElement = SVGFontFaceFormatElement { unSVGFontFaceFormatElement :: JSVal }
+
+instance Eq (SVGFontFaceFormatElement) where
+  (SVGFontFaceFormatElement a) == (SVGFontFaceFormatElement b) = js_eq a b
+
+instance PToJSVal SVGFontFaceFormatElement where
+  pToJSVal = unSVGFontFaceFormatElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SVGFontFaceFormatElement where
+  pFromJSVal = SVGFontFaceFormatElement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SVGFontFaceFormatElement where
+  toJSVal = return . unSVGFontFaceFormatElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SVGFontFaceFormatElement where
+  fromJSVal = return . fmap SVGFontFaceFormatElement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsSVGElement SVGFontFaceFormatElement
+instance IsElement SVGFontFaceFormatElement
+instance IsNode SVGFontFaceFormatElement
+instance IsEventTarget SVGFontFaceFormatElement
+instance IsGObject SVGFontFaceFormatElement where
+  typeGType _ = gTypeSVGFontFaceFormatElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SVGFontFaceFormatElement\"]" gTypeSVGFontFaceFormatElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SVGFontFaceNameElement".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.SVGElement"
+--     * "GHCJS.DOM.Element"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SVGFontFaceNameElement Mozilla SVGFontFaceNameElement documentation>
+newtype SVGFontFaceNameElement = SVGFontFaceNameElement { unSVGFontFaceNameElement :: JSVal }
+
+instance Eq (SVGFontFaceNameElement) where
+  (SVGFontFaceNameElement a) == (SVGFontFaceNameElement b) = js_eq a b
+
+instance PToJSVal SVGFontFaceNameElement where
+  pToJSVal = unSVGFontFaceNameElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SVGFontFaceNameElement where
+  pFromJSVal = SVGFontFaceNameElement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SVGFontFaceNameElement where
+  toJSVal = return . unSVGFontFaceNameElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SVGFontFaceNameElement where
+  fromJSVal = return . fmap SVGFontFaceNameElement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsSVGElement SVGFontFaceNameElement
+instance IsElement SVGFontFaceNameElement
+instance IsNode SVGFontFaceNameElement
+instance IsEventTarget SVGFontFaceNameElement
+instance IsGObject SVGFontFaceNameElement where
+  typeGType _ = gTypeSVGFontFaceNameElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SVGFontFaceNameElement\"]" gTypeSVGFontFaceNameElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SVGFontFaceSrcElement".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.SVGElement"
+--     * "GHCJS.DOM.Element"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SVGFontFaceSrcElement Mozilla SVGFontFaceSrcElement documentation>
+newtype SVGFontFaceSrcElement = SVGFontFaceSrcElement { unSVGFontFaceSrcElement :: JSVal }
+
+instance Eq (SVGFontFaceSrcElement) where
+  (SVGFontFaceSrcElement a) == (SVGFontFaceSrcElement b) = js_eq a b
+
+instance PToJSVal SVGFontFaceSrcElement where
+  pToJSVal = unSVGFontFaceSrcElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SVGFontFaceSrcElement where
+  pFromJSVal = SVGFontFaceSrcElement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SVGFontFaceSrcElement where
+  toJSVal = return . unSVGFontFaceSrcElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SVGFontFaceSrcElement where
+  fromJSVal = return . fmap SVGFontFaceSrcElement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsSVGElement SVGFontFaceSrcElement
+instance IsElement SVGFontFaceSrcElement
+instance IsNode SVGFontFaceSrcElement
+instance IsEventTarget SVGFontFaceSrcElement
+instance IsGObject SVGFontFaceSrcElement where
+  typeGType _ = gTypeSVGFontFaceSrcElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SVGFontFaceSrcElement\"]" gTypeSVGFontFaceSrcElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SVGFontFaceUriElement".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.SVGElement"
+--     * "GHCJS.DOM.Element"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SVGFontFaceUriElement Mozilla SVGFontFaceUriElement documentation>
+newtype SVGFontFaceUriElement = SVGFontFaceUriElement { unSVGFontFaceUriElement :: JSVal }
+
+instance Eq (SVGFontFaceUriElement) where
+  (SVGFontFaceUriElement a) == (SVGFontFaceUriElement b) = js_eq a b
+
+instance PToJSVal SVGFontFaceUriElement where
+  pToJSVal = unSVGFontFaceUriElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SVGFontFaceUriElement where
+  pFromJSVal = SVGFontFaceUriElement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SVGFontFaceUriElement where
+  toJSVal = return . unSVGFontFaceUriElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SVGFontFaceUriElement where
+  fromJSVal = return . fmap SVGFontFaceUriElement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsSVGElement SVGFontFaceUriElement
+instance IsElement SVGFontFaceUriElement
+instance IsNode SVGFontFaceUriElement
+instance IsEventTarget SVGFontFaceUriElement
+instance IsGObject SVGFontFaceUriElement where
+  typeGType _ = gTypeSVGFontFaceUriElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SVGFontFaceUriElement\"]" gTypeSVGFontFaceUriElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SVGForeignObjectElement".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.SVGGraphicsElement"
+--     * "GHCJS.DOM.SVGElement"
+--     * "GHCJS.DOM.Element"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SVGForeignObjectElement Mozilla SVGForeignObjectElement documentation>
+newtype SVGForeignObjectElement = SVGForeignObjectElement { unSVGForeignObjectElement :: JSVal }
+
+instance Eq (SVGForeignObjectElement) where
+  (SVGForeignObjectElement a) == (SVGForeignObjectElement b) = js_eq a b
+
+instance PToJSVal SVGForeignObjectElement where
+  pToJSVal = unSVGForeignObjectElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SVGForeignObjectElement where
+  pFromJSVal = SVGForeignObjectElement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SVGForeignObjectElement where
+  toJSVal = return . unSVGForeignObjectElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SVGForeignObjectElement where
+  fromJSVal = return . fmap SVGForeignObjectElement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsSVGGraphicsElement SVGForeignObjectElement
+instance IsSVGElement SVGForeignObjectElement
+instance IsElement SVGForeignObjectElement
+instance IsNode SVGForeignObjectElement
+instance IsEventTarget SVGForeignObjectElement
+instance IsGObject SVGForeignObjectElement where
+  typeGType _ = gTypeSVGForeignObjectElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SVGForeignObjectElement\"]" gTypeSVGForeignObjectElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SVGGElement".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.SVGGraphicsElement"
+--     * "GHCJS.DOM.SVGElement"
+--     * "GHCJS.DOM.Element"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SVGGElement Mozilla SVGGElement documentation>
+newtype SVGGElement = SVGGElement { unSVGGElement :: JSVal }
+
+instance Eq (SVGGElement) where
+  (SVGGElement a) == (SVGGElement b) = js_eq a b
+
+instance PToJSVal SVGGElement where
+  pToJSVal = unSVGGElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SVGGElement where
+  pFromJSVal = SVGGElement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SVGGElement where
+  toJSVal = return . unSVGGElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SVGGElement where
+  fromJSVal = return . fmap SVGGElement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsSVGGraphicsElement SVGGElement
+instance IsSVGElement SVGGElement
+instance IsElement SVGGElement
+instance IsNode SVGGElement
+instance IsEventTarget SVGGElement
+instance IsGObject SVGGElement where
+  typeGType _ = gTypeSVGGElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SVGGElement\"]" gTypeSVGGElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SVGGlyphElement".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.SVGElement"
+--     * "GHCJS.DOM.Element"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SVGGlyphElement Mozilla SVGGlyphElement documentation>
+newtype SVGGlyphElement = SVGGlyphElement { unSVGGlyphElement :: JSVal }
+
+instance Eq (SVGGlyphElement) where
+  (SVGGlyphElement a) == (SVGGlyphElement b) = js_eq a b
+
+instance PToJSVal SVGGlyphElement where
+  pToJSVal = unSVGGlyphElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SVGGlyphElement where
+  pFromJSVal = SVGGlyphElement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SVGGlyphElement where
+  toJSVal = return . unSVGGlyphElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SVGGlyphElement where
+  fromJSVal = return . fmap SVGGlyphElement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsSVGElement SVGGlyphElement
+instance IsElement SVGGlyphElement
+instance IsNode SVGGlyphElement
+instance IsEventTarget SVGGlyphElement
+instance IsGObject SVGGlyphElement where
+  typeGType _ = gTypeSVGGlyphElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SVGGlyphElement\"]" gTypeSVGGlyphElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SVGGlyphRefElement".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.SVGElement"
+--     * "GHCJS.DOM.Element"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SVGGlyphRefElement Mozilla SVGGlyphRefElement documentation>
+newtype SVGGlyphRefElement = SVGGlyphRefElement { unSVGGlyphRefElement :: JSVal }
+
+instance Eq (SVGGlyphRefElement) where
+  (SVGGlyphRefElement a) == (SVGGlyphRefElement b) = js_eq a b
+
+instance PToJSVal SVGGlyphRefElement where
+  pToJSVal = unSVGGlyphRefElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SVGGlyphRefElement where
+  pFromJSVal = SVGGlyphRefElement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SVGGlyphRefElement where
+  toJSVal = return . unSVGGlyphRefElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SVGGlyphRefElement where
+  fromJSVal = return . fmap SVGGlyphRefElement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsSVGElement SVGGlyphRefElement
+instance IsElement SVGGlyphRefElement
+instance IsNode SVGGlyphRefElement
+instance IsEventTarget SVGGlyphRefElement
+instance IsGObject SVGGlyphRefElement where
+  typeGType _ = gTypeSVGGlyphRefElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SVGGlyphRefElement\"]" gTypeSVGGlyphRefElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SVGGradientElement".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.SVGElement"
+--     * "GHCJS.DOM.Element"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SVGGradientElement Mozilla SVGGradientElement documentation>
+newtype SVGGradientElement = SVGGradientElement { unSVGGradientElement :: JSVal }
+
+instance Eq (SVGGradientElement) where
+  (SVGGradientElement a) == (SVGGradientElement b) = js_eq a b
+
+instance PToJSVal SVGGradientElement where
+  pToJSVal = unSVGGradientElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SVGGradientElement where
+  pFromJSVal = SVGGradientElement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SVGGradientElement where
+  toJSVal = return . unSVGGradientElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SVGGradientElement where
+  fromJSVal = return . fmap SVGGradientElement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+class IsSVGElement o => IsSVGGradientElement o
+toSVGGradientElement :: IsSVGGradientElement o => o -> SVGGradientElement
+toSVGGradientElement = SVGGradientElement . coerce
+
+instance IsSVGGradientElement SVGGradientElement
+instance IsSVGElement SVGGradientElement
+instance IsElement SVGGradientElement
+instance IsNode SVGGradientElement
+instance IsEventTarget SVGGradientElement
+instance IsGObject SVGGradientElement where
+  typeGType _ = gTypeSVGGradientElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SVGGradientElement\"]" gTypeSVGGradientElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SVGGraphicsElement".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.SVGElement"
+--     * "GHCJS.DOM.Element"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SVGGraphicsElement Mozilla SVGGraphicsElement documentation>
+newtype SVGGraphicsElement = SVGGraphicsElement { unSVGGraphicsElement :: JSVal }
+
+instance Eq (SVGGraphicsElement) where
+  (SVGGraphicsElement a) == (SVGGraphicsElement b) = js_eq a b
+
+instance PToJSVal SVGGraphicsElement where
+  pToJSVal = unSVGGraphicsElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SVGGraphicsElement where
+  pFromJSVal = SVGGraphicsElement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SVGGraphicsElement where
+  toJSVal = return . unSVGGraphicsElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SVGGraphicsElement where
+  fromJSVal = return . fmap SVGGraphicsElement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+class IsSVGElement o => IsSVGGraphicsElement o
+toSVGGraphicsElement :: IsSVGGraphicsElement o => o -> SVGGraphicsElement
+toSVGGraphicsElement = SVGGraphicsElement . coerce
+
+instance IsSVGGraphicsElement SVGGraphicsElement
+instance IsSVGElement SVGGraphicsElement
+instance IsElement SVGGraphicsElement
+instance IsNode SVGGraphicsElement
+instance IsEventTarget SVGGraphicsElement
+instance IsGObject SVGGraphicsElement where
+  typeGType _ = gTypeSVGGraphicsElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SVGGraphicsElement\"]" gTypeSVGGraphicsElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SVGHKernElement".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.SVGElement"
+--     * "GHCJS.DOM.Element"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SVGHKernElement Mozilla SVGHKernElement documentation>
+newtype SVGHKernElement = SVGHKernElement { unSVGHKernElement :: JSVal }
+
+instance Eq (SVGHKernElement) where
+  (SVGHKernElement a) == (SVGHKernElement b) = js_eq a b
+
+instance PToJSVal SVGHKernElement where
+  pToJSVal = unSVGHKernElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SVGHKernElement where
+  pFromJSVal = SVGHKernElement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SVGHKernElement where
+  toJSVal = return . unSVGHKernElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SVGHKernElement where
+  fromJSVal = return . fmap SVGHKernElement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsSVGElement SVGHKernElement
+instance IsElement SVGHKernElement
+instance IsNode SVGHKernElement
+instance IsEventTarget SVGHKernElement
+instance IsGObject SVGHKernElement where
+  typeGType _ = gTypeSVGHKernElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SVGHKernElement\"]" gTypeSVGHKernElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SVGImageElement".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.SVGGraphicsElement"
+--     * "GHCJS.DOM.SVGElement"
+--     * "GHCJS.DOM.Element"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SVGImageElement Mozilla SVGImageElement documentation>
+newtype SVGImageElement = SVGImageElement { unSVGImageElement :: JSVal }
+
+instance Eq (SVGImageElement) where
+  (SVGImageElement a) == (SVGImageElement b) = js_eq a b
+
+instance PToJSVal SVGImageElement where
+  pToJSVal = unSVGImageElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SVGImageElement where
+  pFromJSVal = SVGImageElement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SVGImageElement where
+  toJSVal = return . unSVGImageElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SVGImageElement where
+  fromJSVal = return . fmap SVGImageElement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsSVGGraphicsElement SVGImageElement
+instance IsSVGElement SVGImageElement
+instance IsElement SVGImageElement
+instance IsNode SVGImageElement
+instance IsEventTarget SVGImageElement
+instance IsGObject SVGImageElement where
+  typeGType _ = gTypeSVGImageElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SVGImageElement\"]" gTypeSVGImageElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SVGLength".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SVGLength Mozilla SVGLength documentation>
+newtype SVGLength = SVGLength { unSVGLength :: JSVal }
+
+instance Eq (SVGLength) where
+  (SVGLength a) == (SVGLength b) = js_eq a b
+
+instance PToJSVal SVGLength where
+  pToJSVal = unSVGLength
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SVGLength where
+  pFromJSVal = SVGLength
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SVGLength where
+  toJSVal = return . unSVGLength
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SVGLength where
+  fromJSVal = return . fmap SVGLength . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject SVGLength where
+  typeGType _ = gTypeSVGLength
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SVGLength\"]" gTypeSVGLength :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SVGLengthList".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SVGLengthList Mozilla SVGLengthList documentation>
+newtype SVGLengthList = SVGLengthList { unSVGLengthList :: JSVal }
+
+instance Eq (SVGLengthList) where
+  (SVGLengthList a) == (SVGLengthList b) = js_eq a b
+
+instance PToJSVal SVGLengthList where
+  pToJSVal = unSVGLengthList
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SVGLengthList where
+  pFromJSVal = SVGLengthList
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SVGLengthList where
+  toJSVal = return . unSVGLengthList
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SVGLengthList where
+  fromJSVal = return . fmap SVGLengthList . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject SVGLengthList where
+  typeGType _ = gTypeSVGLengthList
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SVGLengthList\"]" gTypeSVGLengthList :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SVGLineElement".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.SVGGraphicsElement"
+--     * "GHCJS.DOM.SVGElement"
+--     * "GHCJS.DOM.Element"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SVGLineElement Mozilla SVGLineElement documentation>
+newtype SVGLineElement = SVGLineElement { unSVGLineElement :: JSVal }
+
+instance Eq (SVGLineElement) where
+  (SVGLineElement a) == (SVGLineElement b) = js_eq a b
+
+instance PToJSVal SVGLineElement where
+  pToJSVal = unSVGLineElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SVGLineElement where
+  pFromJSVal = SVGLineElement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SVGLineElement where
+  toJSVal = return . unSVGLineElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SVGLineElement where
+  fromJSVal = return . fmap SVGLineElement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsSVGGraphicsElement SVGLineElement
+instance IsSVGElement SVGLineElement
+instance IsElement SVGLineElement
+instance IsNode SVGLineElement
+instance IsEventTarget SVGLineElement
+instance IsGObject SVGLineElement where
+  typeGType _ = gTypeSVGLineElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SVGLineElement\"]" gTypeSVGLineElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SVGLinearGradientElement".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.SVGGradientElement"
+--     * "GHCJS.DOM.SVGElement"
+--     * "GHCJS.DOM.Element"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SVGLinearGradientElement Mozilla SVGLinearGradientElement documentation>
+newtype SVGLinearGradientElement = SVGLinearGradientElement { unSVGLinearGradientElement :: JSVal }
+
+instance Eq (SVGLinearGradientElement) where
+  (SVGLinearGradientElement a) == (SVGLinearGradientElement b) = js_eq a b
+
+instance PToJSVal SVGLinearGradientElement where
+  pToJSVal = unSVGLinearGradientElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SVGLinearGradientElement where
+  pFromJSVal = SVGLinearGradientElement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SVGLinearGradientElement where
+  toJSVal = return . unSVGLinearGradientElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SVGLinearGradientElement where
+  fromJSVal = return . fmap SVGLinearGradientElement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsSVGGradientElement SVGLinearGradientElement
+instance IsSVGElement SVGLinearGradientElement
+instance IsElement SVGLinearGradientElement
+instance IsNode SVGLinearGradientElement
+instance IsEventTarget SVGLinearGradientElement
+instance IsGObject SVGLinearGradientElement where
+  typeGType _ = gTypeSVGLinearGradientElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SVGLinearGradientElement\"]" gTypeSVGLinearGradientElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SVGMPathElement".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.SVGElement"
+--     * "GHCJS.DOM.Element"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SVGMPathElement Mozilla SVGMPathElement documentation>
+newtype SVGMPathElement = SVGMPathElement { unSVGMPathElement :: JSVal }
+
+instance Eq (SVGMPathElement) where
+  (SVGMPathElement a) == (SVGMPathElement b) = js_eq a b
+
+instance PToJSVal SVGMPathElement where
+  pToJSVal = unSVGMPathElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SVGMPathElement where
+  pFromJSVal = SVGMPathElement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SVGMPathElement where
+  toJSVal = return . unSVGMPathElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SVGMPathElement where
+  fromJSVal = return . fmap SVGMPathElement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsSVGElement SVGMPathElement
+instance IsElement SVGMPathElement
+instance IsNode SVGMPathElement
+instance IsEventTarget SVGMPathElement
+instance IsGObject SVGMPathElement where
+  typeGType _ = gTypeSVGMPathElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SVGMPathElement\"]" gTypeSVGMPathElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SVGMarkerElement".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.SVGElement"
+--     * "GHCJS.DOM.Element"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SVGMarkerElement Mozilla SVGMarkerElement documentation>
+newtype SVGMarkerElement = SVGMarkerElement { unSVGMarkerElement :: JSVal }
+
+instance Eq (SVGMarkerElement) where
+  (SVGMarkerElement a) == (SVGMarkerElement b) = js_eq a b
+
+instance PToJSVal SVGMarkerElement where
+  pToJSVal = unSVGMarkerElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SVGMarkerElement where
+  pFromJSVal = SVGMarkerElement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SVGMarkerElement where
+  toJSVal = return . unSVGMarkerElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SVGMarkerElement where
+  fromJSVal = return . fmap SVGMarkerElement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsSVGElement SVGMarkerElement
+instance IsElement SVGMarkerElement
+instance IsNode SVGMarkerElement
+instance IsEventTarget SVGMarkerElement
+instance IsGObject SVGMarkerElement where
+  typeGType _ = gTypeSVGMarkerElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SVGMarkerElement\"]" gTypeSVGMarkerElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SVGMaskElement".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.SVGElement"
+--     * "GHCJS.DOM.Element"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SVGMaskElement Mozilla SVGMaskElement documentation>
+newtype SVGMaskElement = SVGMaskElement { unSVGMaskElement :: JSVal }
+
+instance Eq (SVGMaskElement) where
+  (SVGMaskElement a) == (SVGMaskElement b) = js_eq a b
+
+instance PToJSVal SVGMaskElement where
+  pToJSVal = unSVGMaskElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SVGMaskElement where
+  pFromJSVal = SVGMaskElement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SVGMaskElement where
+  toJSVal = return . unSVGMaskElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SVGMaskElement where
+  fromJSVal = return . fmap SVGMaskElement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsSVGElement SVGMaskElement
+instance IsElement SVGMaskElement
+instance IsNode SVGMaskElement
+instance IsEventTarget SVGMaskElement
+instance IsGObject SVGMaskElement where
+  typeGType _ = gTypeSVGMaskElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SVGMaskElement\"]" gTypeSVGMaskElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SVGMatrix".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SVGMatrix Mozilla SVGMatrix documentation>
+newtype SVGMatrix = SVGMatrix { unSVGMatrix :: JSVal }
+
+instance Eq (SVGMatrix) where
+  (SVGMatrix a) == (SVGMatrix b) = js_eq a b
+
+instance PToJSVal SVGMatrix where
+  pToJSVal = unSVGMatrix
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SVGMatrix where
+  pFromJSVal = SVGMatrix
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SVGMatrix where
+  toJSVal = return . unSVGMatrix
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SVGMatrix where
+  fromJSVal = return . fmap SVGMatrix . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject SVGMatrix where
+  typeGType _ = gTypeSVGMatrix
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SVGMatrix\"]" gTypeSVGMatrix :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SVGMetadataElement".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.SVGElement"
+--     * "GHCJS.DOM.Element"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SVGMetadataElement Mozilla SVGMetadataElement documentation>
+newtype SVGMetadataElement = SVGMetadataElement { unSVGMetadataElement :: JSVal }
+
+instance Eq (SVGMetadataElement) where
+  (SVGMetadataElement a) == (SVGMetadataElement b) = js_eq a b
+
+instance PToJSVal SVGMetadataElement where
+  pToJSVal = unSVGMetadataElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SVGMetadataElement where
+  pFromJSVal = SVGMetadataElement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SVGMetadataElement where
+  toJSVal = return . unSVGMetadataElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SVGMetadataElement where
+  fromJSVal = return . fmap SVGMetadataElement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsSVGElement SVGMetadataElement
+instance IsElement SVGMetadataElement
+instance IsNode SVGMetadataElement
+instance IsEventTarget SVGMetadataElement
+instance IsGObject SVGMetadataElement where
+  typeGType _ = gTypeSVGMetadataElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SVGMetadataElement\"]" gTypeSVGMetadataElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SVGMissingGlyphElement".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.SVGElement"
+--     * "GHCJS.DOM.Element"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SVGMissingGlyphElement Mozilla SVGMissingGlyphElement documentation>
+newtype SVGMissingGlyphElement = SVGMissingGlyphElement { unSVGMissingGlyphElement :: JSVal }
+
+instance Eq (SVGMissingGlyphElement) where
+  (SVGMissingGlyphElement a) == (SVGMissingGlyphElement b) = js_eq a b
+
+instance PToJSVal SVGMissingGlyphElement where
+  pToJSVal = unSVGMissingGlyphElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SVGMissingGlyphElement where
+  pFromJSVal = SVGMissingGlyphElement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SVGMissingGlyphElement where
+  toJSVal = return . unSVGMissingGlyphElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SVGMissingGlyphElement where
+  fromJSVal = return . fmap SVGMissingGlyphElement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsSVGElement SVGMissingGlyphElement
+instance IsElement SVGMissingGlyphElement
+instance IsNode SVGMissingGlyphElement
+instance IsEventTarget SVGMissingGlyphElement
+instance IsGObject SVGMissingGlyphElement where
+  typeGType _ = gTypeSVGMissingGlyphElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SVGMissingGlyphElement\"]" gTypeSVGMissingGlyphElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SVGNumber".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SVGNumber Mozilla SVGNumber documentation>
+newtype SVGNumber = SVGNumber { unSVGNumber :: JSVal }
+
+instance Eq (SVGNumber) where
+  (SVGNumber a) == (SVGNumber b) = js_eq a b
+
+instance PToJSVal SVGNumber where
+  pToJSVal = unSVGNumber
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SVGNumber where
+  pFromJSVal = SVGNumber
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SVGNumber where
+  toJSVal = return . unSVGNumber
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SVGNumber where
+  fromJSVal = return . fmap SVGNumber . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject SVGNumber where
+  typeGType _ = gTypeSVGNumber
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SVGNumber\"]" gTypeSVGNumber :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SVGNumberList".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SVGNumberList Mozilla SVGNumberList documentation>
+newtype SVGNumberList = SVGNumberList { unSVGNumberList :: JSVal }
+
+instance Eq (SVGNumberList) where
+  (SVGNumberList a) == (SVGNumberList b) = js_eq a b
+
+instance PToJSVal SVGNumberList where
+  pToJSVal = unSVGNumberList
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SVGNumberList where
+  pFromJSVal = SVGNumberList
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SVGNumberList where
+  toJSVal = return . unSVGNumberList
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SVGNumberList where
+  fromJSVal = return . fmap SVGNumberList . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject SVGNumberList where
+  typeGType _ = gTypeSVGNumberList
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SVGNumberList\"]" gTypeSVGNumberList :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SVGPaint".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.SVGColor"
+--     * "GHCJS.DOM.CSSValue"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SVGPaint Mozilla SVGPaint documentation>
+newtype SVGPaint = SVGPaint { unSVGPaint :: JSVal }
+
+instance Eq (SVGPaint) where
+  (SVGPaint a) == (SVGPaint b) = js_eq a b
+
+instance PToJSVal SVGPaint where
+  pToJSVal = unSVGPaint
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SVGPaint where
+  pFromJSVal = SVGPaint
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SVGPaint where
+  toJSVal = return . unSVGPaint
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SVGPaint where
+  fromJSVal = return . fmap SVGPaint . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsSVGColor SVGPaint
+instance IsCSSValue SVGPaint
+instance IsGObject SVGPaint where
+  typeGType _ = gTypeSVGPaint
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SVGPaint\"]" gTypeSVGPaint :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SVGPathElement".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.SVGGraphicsElement"
+--     * "GHCJS.DOM.SVGElement"
+--     * "GHCJS.DOM.Element"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathElement Mozilla SVGPathElement documentation>
+newtype SVGPathElement = SVGPathElement { unSVGPathElement :: JSVal }
+
+instance Eq (SVGPathElement) where
+  (SVGPathElement a) == (SVGPathElement b) = js_eq a b
+
+instance PToJSVal SVGPathElement where
+  pToJSVal = unSVGPathElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SVGPathElement where
+  pFromJSVal = SVGPathElement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SVGPathElement where
+  toJSVal = return . unSVGPathElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SVGPathElement where
+  fromJSVal = return . fmap SVGPathElement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsSVGGraphicsElement SVGPathElement
+instance IsSVGElement SVGPathElement
+instance IsElement SVGPathElement
+instance IsNode SVGPathElement
+instance IsEventTarget SVGPathElement
+instance IsGObject SVGPathElement where
+  typeGType _ = gTypeSVGPathElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SVGPathElement\"]" gTypeSVGPathElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SVGPathSeg".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathSeg Mozilla SVGPathSeg documentation>
+newtype SVGPathSeg = SVGPathSeg { unSVGPathSeg :: JSVal }
+
+instance Eq (SVGPathSeg) where
+  (SVGPathSeg a) == (SVGPathSeg b) = js_eq a b
+
+instance PToJSVal SVGPathSeg where
+  pToJSVal = unSVGPathSeg
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SVGPathSeg where
+  pFromJSVal = SVGPathSeg
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SVGPathSeg where
+  toJSVal = return . unSVGPathSeg
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SVGPathSeg where
+  fromJSVal = return . fmap SVGPathSeg . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+class IsGObject o => IsSVGPathSeg o
+toSVGPathSeg :: IsSVGPathSeg o => o -> SVGPathSeg
+toSVGPathSeg = SVGPathSeg . coerce
+
+instance IsSVGPathSeg SVGPathSeg
+instance IsGObject SVGPathSeg where
+  typeGType _ = gTypeSVGPathSeg
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SVGPathSeg\"]" gTypeSVGPathSeg :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SVGPathSegArcAbs".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.SVGPathSeg"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathSegArcAbs Mozilla SVGPathSegArcAbs documentation>
+newtype SVGPathSegArcAbs = SVGPathSegArcAbs { unSVGPathSegArcAbs :: JSVal }
+
+instance Eq (SVGPathSegArcAbs) where
+  (SVGPathSegArcAbs a) == (SVGPathSegArcAbs b) = js_eq a b
+
+instance PToJSVal SVGPathSegArcAbs where
+  pToJSVal = unSVGPathSegArcAbs
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SVGPathSegArcAbs where
+  pFromJSVal = SVGPathSegArcAbs
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SVGPathSegArcAbs where
+  toJSVal = return . unSVGPathSegArcAbs
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SVGPathSegArcAbs where
+  fromJSVal = return . fmap SVGPathSegArcAbs . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsSVGPathSeg SVGPathSegArcAbs
+instance IsGObject SVGPathSegArcAbs where
+  typeGType _ = gTypeSVGPathSegArcAbs
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SVGPathSegArcAbs\"]" gTypeSVGPathSegArcAbs :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SVGPathSegArcRel".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.SVGPathSeg"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathSegArcRel Mozilla SVGPathSegArcRel documentation>
+newtype SVGPathSegArcRel = SVGPathSegArcRel { unSVGPathSegArcRel :: JSVal }
+
+instance Eq (SVGPathSegArcRel) where
+  (SVGPathSegArcRel a) == (SVGPathSegArcRel b) = js_eq a b
+
+instance PToJSVal SVGPathSegArcRel where
+  pToJSVal = unSVGPathSegArcRel
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SVGPathSegArcRel where
+  pFromJSVal = SVGPathSegArcRel
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SVGPathSegArcRel where
+  toJSVal = return . unSVGPathSegArcRel
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SVGPathSegArcRel where
+  fromJSVal = return . fmap SVGPathSegArcRel . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsSVGPathSeg SVGPathSegArcRel
+instance IsGObject SVGPathSegArcRel where
+  typeGType _ = gTypeSVGPathSegArcRel
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SVGPathSegArcRel\"]" gTypeSVGPathSegArcRel :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SVGPathSegClosePath".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.SVGPathSeg"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathSegClosePath Mozilla SVGPathSegClosePath documentation>
+newtype SVGPathSegClosePath = SVGPathSegClosePath { unSVGPathSegClosePath :: JSVal }
+
+instance Eq (SVGPathSegClosePath) where
+  (SVGPathSegClosePath a) == (SVGPathSegClosePath b) = js_eq a b
+
+instance PToJSVal SVGPathSegClosePath where
+  pToJSVal = unSVGPathSegClosePath
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SVGPathSegClosePath where
+  pFromJSVal = SVGPathSegClosePath
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SVGPathSegClosePath where
+  toJSVal = return . unSVGPathSegClosePath
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SVGPathSegClosePath where
+  fromJSVal = return . fmap SVGPathSegClosePath . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsSVGPathSeg SVGPathSegClosePath
+instance IsGObject SVGPathSegClosePath where
+  typeGType _ = gTypeSVGPathSegClosePath
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SVGPathSegClosePath\"]" gTypeSVGPathSegClosePath :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SVGPathSegCurvetoCubicAbs".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.SVGPathSeg"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathSegCurvetoCubicAbs Mozilla SVGPathSegCurvetoCubicAbs documentation>
+newtype SVGPathSegCurvetoCubicAbs = SVGPathSegCurvetoCubicAbs { unSVGPathSegCurvetoCubicAbs :: JSVal }
+
+instance Eq (SVGPathSegCurvetoCubicAbs) where
+  (SVGPathSegCurvetoCubicAbs a) == (SVGPathSegCurvetoCubicAbs b) = js_eq a b
+
+instance PToJSVal SVGPathSegCurvetoCubicAbs where
+  pToJSVal = unSVGPathSegCurvetoCubicAbs
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SVGPathSegCurvetoCubicAbs where
+  pFromJSVal = SVGPathSegCurvetoCubicAbs
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SVGPathSegCurvetoCubicAbs where
+  toJSVal = return . unSVGPathSegCurvetoCubicAbs
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SVGPathSegCurvetoCubicAbs where
+  fromJSVal = return . fmap SVGPathSegCurvetoCubicAbs . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsSVGPathSeg SVGPathSegCurvetoCubicAbs
+instance IsGObject SVGPathSegCurvetoCubicAbs where
+  typeGType _ = gTypeSVGPathSegCurvetoCubicAbs
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SVGPathSegCurvetoCubicAbs\"]" gTypeSVGPathSegCurvetoCubicAbs :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SVGPathSegCurvetoCubicRel".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.SVGPathSeg"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathSegCurvetoCubicRel Mozilla SVGPathSegCurvetoCubicRel documentation>
+newtype SVGPathSegCurvetoCubicRel = SVGPathSegCurvetoCubicRel { unSVGPathSegCurvetoCubicRel :: JSVal }
+
+instance Eq (SVGPathSegCurvetoCubicRel) where
+  (SVGPathSegCurvetoCubicRel a) == (SVGPathSegCurvetoCubicRel b) = js_eq a b
+
+instance PToJSVal SVGPathSegCurvetoCubicRel where
+  pToJSVal = unSVGPathSegCurvetoCubicRel
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SVGPathSegCurvetoCubicRel where
+  pFromJSVal = SVGPathSegCurvetoCubicRel
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SVGPathSegCurvetoCubicRel where
+  toJSVal = return . unSVGPathSegCurvetoCubicRel
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SVGPathSegCurvetoCubicRel where
+  fromJSVal = return . fmap SVGPathSegCurvetoCubicRel . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsSVGPathSeg SVGPathSegCurvetoCubicRel
+instance IsGObject SVGPathSegCurvetoCubicRel where
+  typeGType _ = gTypeSVGPathSegCurvetoCubicRel
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SVGPathSegCurvetoCubicRel\"]" gTypeSVGPathSegCurvetoCubicRel :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SVGPathSegCurvetoCubicSmoothAbs".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.SVGPathSeg"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathSegCurvetoCubicSmoothAbs Mozilla SVGPathSegCurvetoCubicSmoothAbs documentation>
+newtype SVGPathSegCurvetoCubicSmoothAbs = SVGPathSegCurvetoCubicSmoothAbs { unSVGPathSegCurvetoCubicSmoothAbs :: JSVal }
+
+instance Eq (SVGPathSegCurvetoCubicSmoothAbs) where
+  (SVGPathSegCurvetoCubicSmoothAbs a) == (SVGPathSegCurvetoCubicSmoothAbs b) = js_eq a b
+
+instance PToJSVal SVGPathSegCurvetoCubicSmoothAbs where
+  pToJSVal = unSVGPathSegCurvetoCubicSmoothAbs
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SVGPathSegCurvetoCubicSmoothAbs where
+  pFromJSVal = SVGPathSegCurvetoCubicSmoothAbs
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SVGPathSegCurvetoCubicSmoothAbs where
+  toJSVal = return . unSVGPathSegCurvetoCubicSmoothAbs
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SVGPathSegCurvetoCubicSmoothAbs where
+  fromJSVal = return . fmap SVGPathSegCurvetoCubicSmoothAbs . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsSVGPathSeg SVGPathSegCurvetoCubicSmoothAbs
+instance IsGObject SVGPathSegCurvetoCubicSmoothAbs where
+  typeGType _ = gTypeSVGPathSegCurvetoCubicSmoothAbs
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SVGPathSegCurvetoCubicSmoothAbs\"]" gTypeSVGPathSegCurvetoCubicSmoothAbs :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SVGPathSegCurvetoCubicSmoothRel".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.SVGPathSeg"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathSegCurvetoCubicSmoothRel Mozilla SVGPathSegCurvetoCubicSmoothRel documentation>
+newtype SVGPathSegCurvetoCubicSmoothRel = SVGPathSegCurvetoCubicSmoothRel { unSVGPathSegCurvetoCubicSmoothRel :: JSVal }
+
+instance Eq (SVGPathSegCurvetoCubicSmoothRel) where
+  (SVGPathSegCurvetoCubicSmoothRel a) == (SVGPathSegCurvetoCubicSmoothRel b) = js_eq a b
+
+instance PToJSVal SVGPathSegCurvetoCubicSmoothRel where
+  pToJSVal = unSVGPathSegCurvetoCubicSmoothRel
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SVGPathSegCurvetoCubicSmoothRel where
+  pFromJSVal = SVGPathSegCurvetoCubicSmoothRel
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SVGPathSegCurvetoCubicSmoothRel where
+  toJSVal = return . unSVGPathSegCurvetoCubicSmoothRel
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SVGPathSegCurvetoCubicSmoothRel where
+  fromJSVal = return . fmap SVGPathSegCurvetoCubicSmoothRel . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsSVGPathSeg SVGPathSegCurvetoCubicSmoothRel
+instance IsGObject SVGPathSegCurvetoCubicSmoothRel where
+  typeGType _ = gTypeSVGPathSegCurvetoCubicSmoothRel
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SVGPathSegCurvetoCubicSmoothRel\"]" gTypeSVGPathSegCurvetoCubicSmoothRel :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SVGPathSegCurvetoQuadraticAbs".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.SVGPathSeg"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathSegCurvetoQuadraticAbs Mozilla SVGPathSegCurvetoQuadraticAbs documentation>
+newtype SVGPathSegCurvetoQuadraticAbs = SVGPathSegCurvetoQuadraticAbs { unSVGPathSegCurvetoQuadraticAbs :: JSVal }
+
+instance Eq (SVGPathSegCurvetoQuadraticAbs) where
+  (SVGPathSegCurvetoQuadraticAbs a) == (SVGPathSegCurvetoQuadraticAbs b) = js_eq a b
+
+instance PToJSVal SVGPathSegCurvetoQuadraticAbs where
+  pToJSVal = unSVGPathSegCurvetoQuadraticAbs
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SVGPathSegCurvetoQuadraticAbs where
+  pFromJSVal = SVGPathSegCurvetoQuadraticAbs
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SVGPathSegCurvetoQuadraticAbs where
+  toJSVal = return . unSVGPathSegCurvetoQuadraticAbs
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SVGPathSegCurvetoQuadraticAbs where
+  fromJSVal = return . fmap SVGPathSegCurvetoQuadraticAbs . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsSVGPathSeg SVGPathSegCurvetoQuadraticAbs
+instance IsGObject SVGPathSegCurvetoQuadraticAbs where
+  typeGType _ = gTypeSVGPathSegCurvetoQuadraticAbs
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SVGPathSegCurvetoQuadraticAbs\"]" gTypeSVGPathSegCurvetoQuadraticAbs :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SVGPathSegCurvetoQuadraticRel".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.SVGPathSeg"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathSegCurvetoQuadraticRel Mozilla SVGPathSegCurvetoQuadraticRel documentation>
+newtype SVGPathSegCurvetoQuadraticRel = SVGPathSegCurvetoQuadraticRel { unSVGPathSegCurvetoQuadraticRel :: JSVal }
+
+instance Eq (SVGPathSegCurvetoQuadraticRel) where
+  (SVGPathSegCurvetoQuadraticRel a) == (SVGPathSegCurvetoQuadraticRel b) = js_eq a b
+
+instance PToJSVal SVGPathSegCurvetoQuadraticRel where
+  pToJSVal = unSVGPathSegCurvetoQuadraticRel
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SVGPathSegCurvetoQuadraticRel where
+  pFromJSVal = SVGPathSegCurvetoQuadraticRel
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SVGPathSegCurvetoQuadraticRel where
+  toJSVal = return . unSVGPathSegCurvetoQuadraticRel
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SVGPathSegCurvetoQuadraticRel where
+  fromJSVal = return . fmap SVGPathSegCurvetoQuadraticRel . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsSVGPathSeg SVGPathSegCurvetoQuadraticRel
+instance IsGObject SVGPathSegCurvetoQuadraticRel where
+  typeGType _ = gTypeSVGPathSegCurvetoQuadraticRel
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SVGPathSegCurvetoQuadraticRel\"]" gTypeSVGPathSegCurvetoQuadraticRel :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SVGPathSegCurvetoQuadraticSmoothAbs".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.SVGPathSeg"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathSegCurvetoQuadraticSmoothAbs Mozilla SVGPathSegCurvetoQuadraticSmoothAbs documentation>
+newtype SVGPathSegCurvetoQuadraticSmoothAbs = SVGPathSegCurvetoQuadraticSmoothAbs { unSVGPathSegCurvetoQuadraticSmoothAbs :: JSVal }
+
+instance Eq (SVGPathSegCurvetoQuadraticSmoothAbs) where
+  (SVGPathSegCurvetoQuadraticSmoothAbs a) == (SVGPathSegCurvetoQuadraticSmoothAbs b) = js_eq a b
+
+instance PToJSVal SVGPathSegCurvetoQuadraticSmoothAbs where
+  pToJSVal = unSVGPathSegCurvetoQuadraticSmoothAbs
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SVGPathSegCurvetoQuadraticSmoothAbs where
+  pFromJSVal = SVGPathSegCurvetoQuadraticSmoothAbs
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SVGPathSegCurvetoQuadraticSmoothAbs where
+  toJSVal = return . unSVGPathSegCurvetoQuadraticSmoothAbs
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SVGPathSegCurvetoQuadraticSmoothAbs where
+  fromJSVal = return . fmap SVGPathSegCurvetoQuadraticSmoothAbs . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsSVGPathSeg SVGPathSegCurvetoQuadraticSmoothAbs
+instance IsGObject SVGPathSegCurvetoQuadraticSmoothAbs where
+  typeGType _ = gTypeSVGPathSegCurvetoQuadraticSmoothAbs
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SVGPathSegCurvetoQuadraticSmoothAbs\"]" gTypeSVGPathSegCurvetoQuadraticSmoothAbs :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SVGPathSegCurvetoQuadraticSmoothRel".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.SVGPathSeg"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathSegCurvetoQuadraticSmoothRel Mozilla SVGPathSegCurvetoQuadraticSmoothRel documentation>
+newtype SVGPathSegCurvetoQuadraticSmoothRel = SVGPathSegCurvetoQuadraticSmoothRel { unSVGPathSegCurvetoQuadraticSmoothRel :: JSVal }
+
+instance Eq (SVGPathSegCurvetoQuadraticSmoothRel) where
+  (SVGPathSegCurvetoQuadraticSmoothRel a) == (SVGPathSegCurvetoQuadraticSmoothRel b) = js_eq a b
+
+instance PToJSVal SVGPathSegCurvetoQuadraticSmoothRel where
+  pToJSVal = unSVGPathSegCurvetoQuadraticSmoothRel
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SVGPathSegCurvetoQuadraticSmoothRel where
+  pFromJSVal = SVGPathSegCurvetoQuadraticSmoothRel
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SVGPathSegCurvetoQuadraticSmoothRel where
+  toJSVal = return . unSVGPathSegCurvetoQuadraticSmoothRel
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SVGPathSegCurvetoQuadraticSmoothRel where
+  fromJSVal = return . fmap SVGPathSegCurvetoQuadraticSmoothRel . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsSVGPathSeg SVGPathSegCurvetoQuadraticSmoothRel
+instance IsGObject SVGPathSegCurvetoQuadraticSmoothRel where
+  typeGType _ = gTypeSVGPathSegCurvetoQuadraticSmoothRel
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SVGPathSegCurvetoQuadraticSmoothRel\"]" gTypeSVGPathSegCurvetoQuadraticSmoothRel :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SVGPathSegLinetoAbs".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.SVGPathSeg"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathSegLinetoAbs Mozilla SVGPathSegLinetoAbs documentation>
+newtype SVGPathSegLinetoAbs = SVGPathSegLinetoAbs { unSVGPathSegLinetoAbs :: JSVal }
+
+instance Eq (SVGPathSegLinetoAbs) where
+  (SVGPathSegLinetoAbs a) == (SVGPathSegLinetoAbs b) = js_eq a b
+
+instance PToJSVal SVGPathSegLinetoAbs where
+  pToJSVal = unSVGPathSegLinetoAbs
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SVGPathSegLinetoAbs where
+  pFromJSVal = SVGPathSegLinetoAbs
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SVGPathSegLinetoAbs where
+  toJSVal = return . unSVGPathSegLinetoAbs
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SVGPathSegLinetoAbs where
+  fromJSVal = return . fmap SVGPathSegLinetoAbs . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsSVGPathSeg SVGPathSegLinetoAbs
+instance IsGObject SVGPathSegLinetoAbs where
+  typeGType _ = gTypeSVGPathSegLinetoAbs
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SVGPathSegLinetoAbs\"]" gTypeSVGPathSegLinetoAbs :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SVGPathSegLinetoHorizontalAbs".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.SVGPathSeg"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathSegLinetoHorizontalAbs Mozilla SVGPathSegLinetoHorizontalAbs documentation>
+newtype SVGPathSegLinetoHorizontalAbs = SVGPathSegLinetoHorizontalAbs { unSVGPathSegLinetoHorizontalAbs :: JSVal }
+
+instance Eq (SVGPathSegLinetoHorizontalAbs) where
+  (SVGPathSegLinetoHorizontalAbs a) == (SVGPathSegLinetoHorizontalAbs b) = js_eq a b
+
+instance PToJSVal SVGPathSegLinetoHorizontalAbs where
+  pToJSVal = unSVGPathSegLinetoHorizontalAbs
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SVGPathSegLinetoHorizontalAbs where
+  pFromJSVal = SVGPathSegLinetoHorizontalAbs
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SVGPathSegLinetoHorizontalAbs where
+  toJSVal = return . unSVGPathSegLinetoHorizontalAbs
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SVGPathSegLinetoHorizontalAbs where
+  fromJSVal = return . fmap SVGPathSegLinetoHorizontalAbs . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsSVGPathSeg SVGPathSegLinetoHorizontalAbs
+instance IsGObject SVGPathSegLinetoHorizontalAbs where
+  typeGType _ = gTypeSVGPathSegLinetoHorizontalAbs
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SVGPathSegLinetoHorizontalAbs\"]" gTypeSVGPathSegLinetoHorizontalAbs :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SVGPathSegLinetoHorizontalRel".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.SVGPathSeg"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathSegLinetoHorizontalRel Mozilla SVGPathSegLinetoHorizontalRel documentation>
+newtype SVGPathSegLinetoHorizontalRel = SVGPathSegLinetoHorizontalRel { unSVGPathSegLinetoHorizontalRel :: JSVal }
+
+instance Eq (SVGPathSegLinetoHorizontalRel) where
+  (SVGPathSegLinetoHorizontalRel a) == (SVGPathSegLinetoHorizontalRel b) = js_eq a b
+
+instance PToJSVal SVGPathSegLinetoHorizontalRel where
+  pToJSVal = unSVGPathSegLinetoHorizontalRel
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SVGPathSegLinetoHorizontalRel where
+  pFromJSVal = SVGPathSegLinetoHorizontalRel
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SVGPathSegLinetoHorizontalRel where
+  toJSVal = return . unSVGPathSegLinetoHorizontalRel
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SVGPathSegLinetoHorizontalRel where
+  fromJSVal = return . fmap SVGPathSegLinetoHorizontalRel . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsSVGPathSeg SVGPathSegLinetoHorizontalRel
+instance IsGObject SVGPathSegLinetoHorizontalRel where
+  typeGType _ = gTypeSVGPathSegLinetoHorizontalRel
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SVGPathSegLinetoHorizontalRel\"]" gTypeSVGPathSegLinetoHorizontalRel :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SVGPathSegLinetoRel".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.SVGPathSeg"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathSegLinetoRel Mozilla SVGPathSegLinetoRel documentation>
+newtype SVGPathSegLinetoRel = SVGPathSegLinetoRel { unSVGPathSegLinetoRel :: JSVal }
+
+instance Eq (SVGPathSegLinetoRel) where
+  (SVGPathSegLinetoRel a) == (SVGPathSegLinetoRel b) = js_eq a b
+
+instance PToJSVal SVGPathSegLinetoRel where
+  pToJSVal = unSVGPathSegLinetoRel
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SVGPathSegLinetoRel where
+  pFromJSVal = SVGPathSegLinetoRel
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SVGPathSegLinetoRel where
+  toJSVal = return . unSVGPathSegLinetoRel
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SVGPathSegLinetoRel where
+  fromJSVal = return . fmap SVGPathSegLinetoRel . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsSVGPathSeg SVGPathSegLinetoRel
+instance IsGObject SVGPathSegLinetoRel where
+  typeGType _ = gTypeSVGPathSegLinetoRel
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SVGPathSegLinetoRel\"]" gTypeSVGPathSegLinetoRel :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SVGPathSegLinetoVerticalAbs".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.SVGPathSeg"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathSegLinetoVerticalAbs Mozilla SVGPathSegLinetoVerticalAbs documentation>
+newtype SVGPathSegLinetoVerticalAbs = SVGPathSegLinetoVerticalAbs { unSVGPathSegLinetoVerticalAbs :: JSVal }
+
+instance Eq (SVGPathSegLinetoVerticalAbs) where
+  (SVGPathSegLinetoVerticalAbs a) == (SVGPathSegLinetoVerticalAbs b) = js_eq a b
+
+instance PToJSVal SVGPathSegLinetoVerticalAbs where
+  pToJSVal = unSVGPathSegLinetoVerticalAbs
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SVGPathSegLinetoVerticalAbs where
+  pFromJSVal = SVGPathSegLinetoVerticalAbs
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SVGPathSegLinetoVerticalAbs where
+  toJSVal = return . unSVGPathSegLinetoVerticalAbs
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SVGPathSegLinetoVerticalAbs where
+  fromJSVal = return . fmap SVGPathSegLinetoVerticalAbs . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsSVGPathSeg SVGPathSegLinetoVerticalAbs
+instance IsGObject SVGPathSegLinetoVerticalAbs where
+  typeGType _ = gTypeSVGPathSegLinetoVerticalAbs
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SVGPathSegLinetoVerticalAbs\"]" gTypeSVGPathSegLinetoVerticalAbs :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SVGPathSegLinetoVerticalRel".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.SVGPathSeg"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathSegLinetoVerticalRel Mozilla SVGPathSegLinetoVerticalRel documentation>
+newtype SVGPathSegLinetoVerticalRel = SVGPathSegLinetoVerticalRel { unSVGPathSegLinetoVerticalRel :: JSVal }
+
+instance Eq (SVGPathSegLinetoVerticalRel) where
+  (SVGPathSegLinetoVerticalRel a) == (SVGPathSegLinetoVerticalRel b) = js_eq a b
+
+instance PToJSVal SVGPathSegLinetoVerticalRel where
+  pToJSVal = unSVGPathSegLinetoVerticalRel
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SVGPathSegLinetoVerticalRel where
+  pFromJSVal = SVGPathSegLinetoVerticalRel
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SVGPathSegLinetoVerticalRel where
+  toJSVal = return . unSVGPathSegLinetoVerticalRel
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SVGPathSegLinetoVerticalRel where
+  fromJSVal = return . fmap SVGPathSegLinetoVerticalRel . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsSVGPathSeg SVGPathSegLinetoVerticalRel
+instance IsGObject SVGPathSegLinetoVerticalRel where
+  typeGType _ = gTypeSVGPathSegLinetoVerticalRel
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SVGPathSegLinetoVerticalRel\"]" gTypeSVGPathSegLinetoVerticalRel :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SVGPathSegList".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathSegList Mozilla SVGPathSegList documentation>
+newtype SVGPathSegList = SVGPathSegList { unSVGPathSegList :: JSVal }
+
+instance Eq (SVGPathSegList) where
+  (SVGPathSegList a) == (SVGPathSegList b) = js_eq a b
+
+instance PToJSVal SVGPathSegList where
+  pToJSVal = unSVGPathSegList
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SVGPathSegList where
+  pFromJSVal = SVGPathSegList
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SVGPathSegList where
+  toJSVal = return . unSVGPathSegList
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SVGPathSegList where
+  fromJSVal = return . fmap SVGPathSegList . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject SVGPathSegList where
+  typeGType _ = gTypeSVGPathSegList
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SVGPathSegList\"]" gTypeSVGPathSegList :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SVGPathSegMovetoAbs".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.SVGPathSeg"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathSegMovetoAbs Mozilla SVGPathSegMovetoAbs documentation>
+newtype SVGPathSegMovetoAbs = SVGPathSegMovetoAbs { unSVGPathSegMovetoAbs :: JSVal }
+
+instance Eq (SVGPathSegMovetoAbs) where
+  (SVGPathSegMovetoAbs a) == (SVGPathSegMovetoAbs b) = js_eq a b
+
+instance PToJSVal SVGPathSegMovetoAbs where
+  pToJSVal = unSVGPathSegMovetoAbs
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SVGPathSegMovetoAbs where
+  pFromJSVal = SVGPathSegMovetoAbs
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SVGPathSegMovetoAbs where
+  toJSVal = return . unSVGPathSegMovetoAbs
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SVGPathSegMovetoAbs where
+  fromJSVal = return . fmap SVGPathSegMovetoAbs . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsSVGPathSeg SVGPathSegMovetoAbs
+instance IsGObject SVGPathSegMovetoAbs where
+  typeGType _ = gTypeSVGPathSegMovetoAbs
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SVGPathSegMovetoAbs\"]" gTypeSVGPathSegMovetoAbs :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SVGPathSegMovetoRel".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.SVGPathSeg"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathSegMovetoRel Mozilla SVGPathSegMovetoRel documentation>
+newtype SVGPathSegMovetoRel = SVGPathSegMovetoRel { unSVGPathSegMovetoRel :: JSVal }
+
+instance Eq (SVGPathSegMovetoRel) where
+  (SVGPathSegMovetoRel a) == (SVGPathSegMovetoRel b) = js_eq a b
+
+instance PToJSVal SVGPathSegMovetoRel where
+  pToJSVal = unSVGPathSegMovetoRel
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SVGPathSegMovetoRel where
+  pFromJSVal = SVGPathSegMovetoRel
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SVGPathSegMovetoRel where
+  toJSVal = return . unSVGPathSegMovetoRel
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SVGPathSegMovetoRel where
+  fromJSVal = return . fmap SVGPathSegMovetoRel . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsSVGPathSeg SVGPathSegMovetoRel
+instance IsGObject SVGPathSegMovetoRel where
+  typeGType _ = gTypeSVGPathSegMovetoRel
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SVGPathSegMovetoRel\"]" gTypeSVGPathSegMovetoRel :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SVGPatternElement".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.SVGElement"
+--     * "GHCJS.DOM.Element"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SVGPatternElement Mozilla SVGPatternElement documentation>
+newtype SVGPatternElement = SVGPatternElement { unSVGPatternElement :: JSVal }
+
+instance Eq (SVGPatternElement) where
+  (SVGPatternElement a) == (SVGPatternElement b) = js_eq a b
+
+instance PToJSVal SVGPatternElement where
+  pToJSVal = unSVGPatternElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SVGPatternElement where
+  pFromJSVal = SVGPatternElement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SVGPatternElement where
+  toJSVal = return . unSVGPatternElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SVGPatternElement where
+  fromJSVal = return . fmap SVGPatternElement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsSVGElement SVGPatternElement
+instance IsElement SVGPatternElement
+instance IsNode SVGPatternElement
+instance IsEventTarget SVGPatternElement
+instance IsGObject SVGPatternElement where
+  typeGType _ = gTypeSVGPatternElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SVGPatternElement\"]" gTypeSVGPatternElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SVGPoint".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SVGPoint Mozilla SVGPoint documentation>
+newtype SVGPoint = SVGPoint { unSVGPoint :: JSVal }
+
+instance Eq (SVGPoint) where
+  (SVGPoint a) == (SVGPoint b) = js_eq a b
+
+instance PToJSVal SVGPoint where
+  pToJSVal = unSVGPoint
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SVGPoint where
+  pFromJSVal = SVGPoint
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SVGPoint where
+  toJSVal = return . unSVGPoint
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SVGPoint where
+  fromJSVal = return . fmap SVGPoint . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject SVGPoint where
+  typeGType _ = gTypeSVGPoint
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SVGPoint\"]" gTypeSVGPoint :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SVGPointList".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SVGPointList Mozilla SVGPointList documentation>
+newtype SVGPointList = SVGPointList { unSVGPointList :: JSVal }
+
+instance Eq (SVGPointList) where
+  (SVGPointList a) == (SVGPointList b) = js_eq a b
+
+instance PToJSVal SVGPointList where
+  pToJSVal = unSVGPointList
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SVGPointList where
+  pFromJSVal = SVGPointList
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SVGPointList where
+  toJSVal = return . unSVGPointList
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SVGPointList where
+  fromJSVal = return . fmap SVGPointList . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject SVGPointList where
+  typeGType _ = gTypeSVGPointList
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SVGPointList\"]" gTypeSVGPointList :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SVGPolygonElement".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.SVGGraphicsElement"
+--     * "GHCJS.DOM.SVGElement"
+--     * "GHCJS.DOM.Element"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SVGPolygonElement Mozilla SVGPolygonElement documentation>
+newtype SVGPolygonElement = SVGPolygonElement { unSVGPolygonElement :: JSVal }
+
+instance Eq (SVGPolygonElement) where
+  (SVGPolygonElement a) == (SVGPolygonElement b) = js_eq a b
+
+instance PToJSVal SVGPolygonElement where
+  pToJSVal = unSVGPolygonElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SVGPolygonElement where
+  pFromJSVal = SVGPolygonElement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SVGPolygonElement where
+  toJSVal = return . unSVGPolygonElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SVGPolygonElement where
+  fromJSVal = return . fmap SVGPolygonElement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsSVGGraphicsElement SVGPolygonElement
+instance IsSVGElement SVGPolygonElement
+instance IsElement SVGPolygonElement
+instance IsNode SVGPolygonElement
+instance IsEventTarget SVGPolygonElement
+instance IsGObject SVGPolygonElement where
+  typeGType _ = gTypeSVGPolygonElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SVGPolygonElement\"]" gTypeSVGPolygonElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SVGPolylineElement".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.SVGGraphicsElement"
+--     * "GHCJS.DOM.SVGElement"
+--     * "GHCJS.DOM.Element"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SVGPolylineElement Mozilla SVGPolylineElement documentation>
+newtype SVGPolylineElement = SVGPolylineElement { unSVGPolylineElement :: JSVal }
+
+instance Eq (SVGPolylineElement) where
+  (SVGPolylineElement a) == (SVGPolylineElement b) = js_eq a b
+
+instance PToJSVal SVGPolylineElement where
+  pToJSVal = unSVGPolylineElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SVGPolylineElement where
+  pFromJSVal = SVGPolylineElement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SVGPolylineElement where
+  toJSVal = return . unSVGPolylineElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SVGPolylineElement where
+  fromJSVal = return . fmap SVGPolylineElement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsSVGGraphicsElement SVGPolylineElement
+instance IsSVGElement SVGPolylineElement
+instance IsElement SVGPolylineElement
+instance IsNode SVGPolylineElement
+instance IsEventTarget SVGPolylineElement
+instance IsGObject SVGPolylineElement where
+  typeGType _ = gTypeSVGPolylineElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SVGPolylineElement\"]" gTypeSVGPolylineElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SVGPreserveAspectRatio".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SVGPreserveAspectRatio Mozilla SVGPreserveAspectRatio documentation>
+newtype SVGPreserveAspectRatio = SVGPreserveAspectRatio { unSVGPreserveAspectRatio :: JSVal }
+
+instance Eq (SVGPreserveAspectRatio) where
+  (SVGPreserveAspectRatio a) == (SVGPreserveAspectRatio b) = js_eq a b
+
+instance PToJSVal SVGPreserveAspectRatio where
+  pToJSVal = unSVGPreserveAspectRatio
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SVGPreserveAspectRatio where
+  pFromJSVal = SVGPreserveAspectRatio
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SVGPreserveAspectRatio where
+  toJSVal = return . unSVGPreserveAspectRatio
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SVGPreserveAspectRatio where
+  fromJSVal = return . fmap SVGPreserveAspectRatio . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject SVGPreserveAspectRatio where
+  typeGType _ = gTypeSVGPreserveAspectRatio
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SVGPreserveAspectRatio\"]" gTypeSVGPreserveAspectRatio :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SVGRadialGradientElement".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.SVGGradientElement"
+--     * "GHCJS.DOM.SVGElement"
+--     * "GHCJS.DOM.Element"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SVGRadialGradientElement Mozilla SVGRadialGradientElement documentation>
+newtype SVGRadialGradientElement = SVGRadialGradientElement { unSVGRadialGradientElement :: JSVal }
+
+instance Eq (SVGRadialGradientElement) where
+  (SVGRadialGradientElement a) == (SVGRadialGradientElement b) = js_eq a b
+
+instance PToJSVal SVGRadialGradientElement where
+  pToJSVal = unSVGRadialGradientElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SVGRadialGradientElement where
+  pFromJSVal = SVGRadialGradientElement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SVGRadialGradientElement where
+  toJSVal = return . unSVGRadialGradientElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SVGRadialGradientElement where
+  fromJSVal = return . fmap SVGRadialGradientElement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsSVGGradientElement SVGRadialGradientElement
+instance IsSVGElement SVGRadialGradientElement
+instance IsElement SVGRadialGradientElement
+instance IsNode SVGRadialGradientElement
+instance IsEventTarget SVGRadialGradientElement
+instance IsGObject SVGRadialGradientElement where
+  typeGType _ = gTypeSVGRadialGradientElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SVGRadialGradientElement\"]" gTypeSVGRadialGradientElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SVGRect".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SVGRect Mozilla SVGRect documentation>
+newtype SVGRect = SVGRect { unSVGRect :: JSVal }
+
+instance Eq (SVGRect) where
+  (SVGRect a) == (SVGRect b) = js_eq a b
+
+instance PToJSVal SVGRect where
+  pToJSVal = unSVGRect
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SVGRect where
+  pFromJSVal = SVGRect
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SVGRect where
+  toJSVal = return . unSVGRect
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SVGRect where
+  fromJSVal = return . fmap SVGRect . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject SVGRect where
+  typeGType _ = gTypeSVGRect
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SVGRect\"]" gTypeSVGRect :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SVGRectElement".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.SVGGraphicsElement"
+--     * "GHCJS.DOM.SVGElement"
+--     * "GHCJS.DOM.Element"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SVGRectElement Mozilla SVGRectElement documentation>
+newtype SVGRectElement = SVGRectElement { unSVGRectElement :: JSVal }
+
+instance Eq (SVGRectElement) where
+  (SVGRectElement a) == (SVGRectElement b) = js_eq a b
+
+instance PToJSVal SVGRectElement where
+  pToJSVal = unSVGRectElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SVGRectElement where
+  pFromJSVal = SVGRectElement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SVGRectElement where
+  toJSVal = return . unSVGRectElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SVGRectElement where
+  fromJSVal = return . fmap SVGRectElement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsSVGGraphicsElement SVGRectElement
+instance IsSVGElement SVGRectElement
+instance IsElement SVGRectElement
+instance IsNode SVGRectElement
+instance IsEventTarget SVGRectElement
+instance IsGObject SVGRectElement where
+  typeGType _ = gTypeSVGRectElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SVGRectElement\"]" gTypeSVGRectElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SVGRenderingIntent".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SVGRenderingIntent Mozilla SVGRenderingIntent documentation>
+newtype SVGRenderingIntent = SVGRenderingIntent { unSVGRenderingIntent :: JSVal }
+
+instance Eq (SVGRenderingIntent) where
+  (SVGRenderingIntent a) == (SVGRenderingIntent b) = js_eq a b
+
+instance PToJSVal SVGRenderingIntent where
+  pToJSVal = unSVGRenderingIntent
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SVGRenderingIntent where
+  pFromJSVal = SVGRenderingIntent
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SVGRenderingIntent where
+  toJSVal = return . unSVGRenderingIntent
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SVGRenderingIntent where
+  fromJSVal = return . fmap SVGRenderingIntent . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject SVGRenderingIntent where
+  typeGType _ = gTypeSVGRenderingIntent
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SVGRenderingIntent\"]" gTypeSVGRenderingIntent :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SVGSVGElement".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.SVGGraphicsElement"
+--     * "GHCJS.DOM.SVGElement"
+--     * "GHCJS.DOM.Element"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SVGSVGElement Mozilla SVGSVGElement documentation>
+newtype SVGSVGElement = SVGSVGElement { unSVGSVGElement :: JSVal }
+
+instance Eq (SVGSVGElement) where
+  (SVGSVGElement a) == (SVGSVGElement b) = js_eq a b
+
+instance PToJSVal SVGSVGElement where
+  pToJSVal = unSVGSVGElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SVGSVGElement where
+  pFromJSVal = SVGSVGElement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SVGSVGElement where
+  toJSVal = return . unSVGSVGElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SVGSVGElement where
+  fromJSVal = return . fmap SVGSVGElement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsSVGGraphicsElement SVGSVGElement
+instance IsSVGElement SVGSVGElement
+instance IsElement SVGSVGElement
+instance IsNode SVGSVGElement
+instance IsEventTarget SVGSVGElement
+instance IsGObject SVGSVGElement where
+  typeGType _ = gTypeSVGSVGElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SVGSVGElement\"]" gTypeSVGSVGElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SVGScriptElement".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.SVGElement"
+--     * "GHCJS.DOM.Element"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SVGScriptElement Mozilla SVGScriptElement documentation>
+newtype SVGScriptElement = SVGScriptElement { unSVGScriptElement :: JSVal }
+
+instance Eq (SVGScriptElement) where
+  (SVGScriptElement a) == (SVGScriptElement b) = js_eq a b
+
+instance PToJSVal SVGScriptElement where
+  pToJSVal = unSVGScriptElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SVGScriptElement where
+  pFromJSVal = SVGScriptElement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SVGScriptElement where
+  toJSVal = return . unSVGScriptElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SVGScriptElement where
+  fromJSVal = return . fmap SVGScriptElement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsSVGElement SVGScriptElement
+instance IsElement SVGScriptElement
+instance IsNode SVGScriptElement
+instance IsEventTarget SVGScriptElement
+instance IsGObject SVGScriptElement where
+  typeGType _ = gTypeSVGScriptElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SVGScriptElement\"]" gTypeSVGScriptElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SVGSetElement".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.SVGAnimationElement"
+--     * "GHCJS.DOM.SVGElement"
+--     * "GHCJS.DOM.Element"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SVGSetElement Mozilla SVGSetElement documentation>
+newtype SVGSetElement = SVGSetElement { unSVGSetElement :: JSVal }
+
+instance Eq (SVGSetElement) where
+  (SVGSetElement a) == (SVGSetElement b) = js_eq a b
+
+instance PToJSVal SVGSetElement where
+  pToJSVal = unSVGSetElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SVGSetElement where
+  pFromJSVal = SVGSetElement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SVGSetElement where
+  toJSVal = return . unSVGSetElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SVGSetElement where
+  fromJSVal = return . fmap SVGSetElement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsSVGAnimationElement SVGSetElement
+instance IsSVGElement SVGSetElement
+instance IsElement SVGSetElement
+instance IsNode SVGSetElement
+instance IsEventTarget SVGSetElement
+instance IsGObject SVGSetElement where
+  typeGType _ = gTypeSVGSetElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SVGSetElement\"]" gTypeSVGSetElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SVGStopElement".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.SVGElement"
+--     * "GHCJS.DOM.Element"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SVGStopElement Mozilla SVGStopElement documentation>
+newtype SVGStopElement = SVGStopElement { unSVGStopElement :: JSVal }
+
+instance Eq (SVGStopElement) where
+  (SVGStopElement a) == (SVGStopElement b) = js_eq a b
+
+instance PToJSVal SVGStopElement where
+  pToJSVal = unSVGStopElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SVGStopElement where
+  pFromJSVal = SVGStopElement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SVGStopElement where
+  toJSVal = return . unSVGStopElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SVGStopElement where
+  fromJSVal = return . fmap SVGStopElement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsSVGElement SVGStopElement
+instance IsElement SVGStopElement
+instance IsNode SVGStopElement
+instance IsEventTarget SVGStopElement
+instance IsGObject SVGStopElement where
+  typeGType _ = gTypeSVGStopElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SVGStopElement\"]" gTypeSVGStopElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SVGStringList".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SVGStringList Mozilla SVGStringList documentation>
+newtype SVGStringList = SVGStringList { unSVGStringList :: JSVal }
+
+instance Eq (SVGStringList) where
+  (SVGStringList a) == (SVGStringList b) = js_eq a b
+
+instance PToJSVal SVGStringList where
+  pToJSVal = unSVGStringList
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SVGStringList where
+  pFromJSVal = SVGStringList
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SVGStringList where
+  toJSVal = return . unSVGStringList
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SVGStringList where
+  fromJSVal = return . fmap SVGStringList . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject SVGStringList where
+  typeGType _ = gTypeSVGStringList
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SVGStringList\"]" gTypeSVGStringList :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SVGStyleElement".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.SVGElement"
+--     * "GHCJS.DOM.Element"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SVGStyleElement Mozilla SVGStyleElement documentation>
+newtype SVGStyleElement = SVGStyleElement { unSVGStyleElement :: JSVal }
+
+instance Eq (SVGStyleElement) where
+  (SVGStyleElement a) == (SVGStyleElement b) = js_eq a b
+
+instance PToJSVal SVGStyleElement where
+  pToJSVal = unSVGStyleElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SVGStyleElement where
+  pFromJSVal = SVGStyleElement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SVGStyleElement where
+  toJSVal = return . unSVGStyleElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SVGStyleElement where
+  fromJSVal = return . fmap SVGStyleElement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsSVGElement SVGStyleElement
+instance IsElement SVGStyleElement
+instance IsNode SVGStyleElement
+instance IsEventTarget SVGStyleElement
+instance IsGObject SVGStyleElement where
+  typeGType _ = gTypeSVGStyleElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SVGStyleElement\"]" gTypeSVGStyleElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SVGSwitchElement".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.SVGGraphicsElement"
+--     * "GHCJS.DOM.SVGElement"
+--     * "GHCJS.DOM.Element"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SVGSwitchElement Mozilla SVGSwitchElement documentation>
+newtype SVGSwitchElement = SVGSwitchElement { unSVGSwitchElement :: JSVal }
+
+instance Eq (SVGSwitchElement) where
+  (SVGSwitchElement a) == (SVGSwitchElement b) = js_eq a b
+
+instance PToJSVal SVGSwitchElement where
+  pToJSVal = unSVGSwitchElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SVGSwitchElement where
+  pFromJSVal = SVGSwitchElement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SVGSwitchElement where
+  toJSVal = return . unSVGSwitchElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SVGSwitchElement where
+  fromJSVal = return . fmap SVGSwitchElement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsSVGGraphicsElement SVGSwitchElement
+instance IsSVGElement SVGSwitchElement
+instance IsElement SVGSwitchElement
+instance IsNode SVGSwitchElement
+instance IsEventTarget SVGSwitchElement
+instance IsGObject SVGSwitchElement where
+  typeGType _ = gTypeSVGSwitchElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SVGSwitchElement\"]" gTypeSVGSwitchElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SVGSymbolElement".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.SVGElement"
+--     * "GHCJS.DOM.Element"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SVGSymbolElement Mozilla SVGSymbolElement documentation>
+newtype SVGSymbolElement = SVGSymbolElement { unSVGSymbolElement :: JSVal }
+
+instance Eq (SVGSymbolElement) where
+  (SVGSymbolElement a) == (SVGSymbolElement b) = js_eq a b
+
+instance PToJSVal SVGSymbolElement where
+  pToJSVal = unSVGSymbolElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SVGSymbolElement where
+  pFromJSVal = SVGSymbolElement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SVGSymbolElement where
+  toJSVal = return . unSVGSymbolElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SVGSymbolElement where
+  fromJSVal = return . fmap SVGSymbolElement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsSVGElement SVGSymbolElement
+instance IsElement SVGSymbolElement
+instance IsNode SVGSymbolElement
+instance IsEventTarget SVGSymbolElement
+instance IsGObject SVGSymbolElement where
+  typeGType _ = gTypeSVGSymbolElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SVGSymbolElement\"]" gTypeSVGSymbolElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SVGTRefElement".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.SVGTextPositioningElement"
+--     * "GHCJS.DOM.SVGTextContentElement"
+--     * "GHCJS.DOM.SVGGraphicsElement"
+--     * "GHCJS.DOM.SVGElement"
+--     * "GHCJS.DOM.Element"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SVGTRefElement Mozilla SVGTRefElement documentation>
+newtype SVGTRefElement = SVGTRefElement { unSVGTRefElement :: JSVal }
+
+instance Eq (SVGTRefElement) where
+  (SVGTRefElement a) == (SVGTRefElement b) = js_eq a b
+
+instance PToJSVal SVGTRefElement where
+  pToJSVal = unSVGTRefElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SVGTRefElement where
+  pFromJSVal = SVGTRefElement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SVGTRefElement where
+  toJSVal = return . unSVGTRefElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SVGTRefElement where
+  fromJSVal = return . fmap SVGTRefElement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsSVGTextPositioningElement SVGTRefElement
+instance IsSVGTextContentElement SVGTRefElement
+instance IsSVGGraphicsElement SVGTRefElement
+instance IsSVGElement SVGTRefElement
+instance IsElement SVGTRefElement
+instance IsNode SVGTRefElement
+instance IsEventTarget SVGTRefElement
+instance IsGObject SVGTRefElement where
+  typeGType _ = gTypeSVGTRefElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SVGTRefElement\"]" gTypeSVGTRefElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SVGTSpanElement".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.SVGTextPositioningElement"
+--     * "GHCJS.DOM.SVGTextContentElement"
+--     * "GHCJS.DOM.SVGGraphicsElement"
+--     * "GHCJS.DOM.SVGElement"
+--     * "GHCJS.DOM.Element"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SVGTSpanElement Mozilla SVGTSpanElement documentation>
+newtype SVGTSpanElement = SVGTSpanElement { unSVGTSpanElement :: JSVal }
+
+instance Eq (SVGTSpanElement) where
+  (SVGTSpanElement a) == (SVGTSpanElement b) = js_eq a b
+
+instance PToJSVal SVGTSpanElement where
+  pToJSVal = unSVGTSpanElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SVGTSpanElement where
+  pFromJSVal = SVGTSpanElement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SVGTSpanElement where
+  toJSVal = return . unSVGTSpanElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SVGTSpanElement where
+  fromJSVal = return . fmap SVGTSpanElement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsSVGTextPositioningElement SVGTSpanElement
+instance IsSVGTextContentElement SVGTSpanElement
+instance IsSVGGraphicsElement SVGTSpanElement
+instance IsSVGElement SVGTSpanElement
+instance IsElement SVGTSpanElement
+instance IsNode SVGTSpanElement
+instance IsEventTarget SVGTSpanElement
+instance IsGObject SVGTSpanElement where
+  typeGType _ = gTypeSVGTSpanElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SVGTSpanElement\"]" gTypeSVGTSpanElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SVGTests".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SVGTests Mozilla SVGTests documentation>
+newtype SVGTests = SVGTests { unSVGTests :: JSVal }
+
+instance Eq (SVGTests) where
+  (SVGTests a) == (SVGTests b) = js_eq a b
+
+instance PToJSVal SVGTests where
+  pToJSVal = unSVGTests
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SVGTests where
+  pFromJSVal = SVGTests
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SVGTests where
+  toJSVal = return . unSVGTests
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SVGTests where
+  fromJSVal = return . fmap SVGTests . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject SVGTests where
+  typeGType _ = gTypeSVGTests
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SVGTests\"]" gTypeSVGTests :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SVGTextContentElement".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.SVGGraphicsElement"
+--     * "GHCJS.DOM.SVGElement"
+--     * "GHCJS.DOM.Element"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SVGTextContentElement Mozilla SVGTextContentElement documentation>
+newtype SVGTextContentElement = SVGTextContentElement { unSVGTextContentElement :: JSVal }
+
+instance Eq (SVGTextContentElement) where
+  (SVGTextContentElement a) == (SVGTextContentElement b) = js_eq a b
+
+instance PToJSVal SVGTextContentElement where
+  pToJSVal = unSVGTextContentElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SVGTextContentElement where
+  pFromJSVal = SVGTextContentElement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SVGTextContentElement where
+  toJSVal = return . unSVGTextContentElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SVGTextContentElement where
+  fromJSVal = return . fmap SVGTextContentElement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+class IsSVGGraphicsElement o => IsSVGTextContentElement o
+toSVGTextContentElement :: IsSVGTextContentElement o => o -> SVGTextContentElement
+toSVGTextContentElement = SVGTextContentElement . coerce
+
+instance IsSVGTextContentElement SVGTextContentElement
+instance IsSVGGraphicsElement SVGTextContentElement
+instance IsSVGElement SVGTextContentElement
+instance IsElement SVGTextContentElement
+instance IsNode SVGTextContentElement
+instance IsEventTarget SVGTextContentElement
+instance IsGObject SVGTextContentElement where
+  typeGType _ = gTypeSVGTextContentElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SVGTextContentElement\"]" gTypeSVGTextContentElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SVGTextElement".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.SVGTextPositioningElement"
+--     * "GHCJS.DOM.SVGTextContentElement"
+--     * "GHCJS.DOM.SVGGraphicsElement"
+--     * "GHCJS.DOM.SVGElement"
+--     * "GHCJS.DOM.Element"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SVGTextElement Mozilla SVGTextElement documentation>
+newtype SVGTextElement = SVGTextElement { unSVGTextElement :: JSVal }
+
+instance Eq (SVGTextElement) where
+  (SVGTextElement a) == (SVGTextElement b) = js_eq a b
+
+instance PToJSVal SVGTextElement where
+  pToJSVal = unSVGTextElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SVGTextElement where
+  pFromJSVal = SVGTextElement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SVGTextElement where
+  toJSVal = return . unSVGTextElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SVGTextElement where
+  fromJSVal = return . fmap SVGTextElement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsSVGTextPositioningElement SVGTextElement
+instance IsSVGTextContentElement SVGTextElement
+instance IsSVGGraphicsElement SVGTextElement
+instance IsSVGElement SVGTextElement
+instance IsElement SVGTextElement
+instance IsNode SVGTextElement
+instance IsEventTarget SVGTextElement
+instance IsGObject SVGTextElement where
+  typeGType _ = gTypeSVGTextElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SVGTextElement\"]" gTypeSVGTextElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SVGTextPathElement".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.SVGTextContentElement"
+--     * "GHCJS.DOM.SVGGraphicsElement"
+--     * "GHCJS.DOM.SVGElement"
+--     * "GHCJS.DOM.Element"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SVGTextPathElement Mozilla SVGTextPathElement documentation>
+newtype SVGTextPathElement = SVGTextPathElement { unSVGTextPathElement :: JSVal }
+
+instance Eq (SVGTextPathElement) where
+  (SVGTextPathElement a) == (SVGTextPathElement b) = js_eq a b
+
+instance PToJSVal SVGTextPathElement where
+  pToJSVal = unSVGTextPathElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SVGTextPathElement where
+  pFromJSVal = SVGTextPathElement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SVGTextPathElement where
+  toJSVal = return . unSVGTextPathElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SVGTextPathElement where
+  fromJSVal = return . fmap SVGTextPathElement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsSVGTextContentElement SVGTextPathElement
+instance IsSVGGraphicsElement SVGTextPathElement
+instance IsSVGElement SVGTextPathElement
+instance IsElement SVGTextPathElement
+instance IsNode SVGTextPathElement
+instance IsEventTarget SVGTextPathElement
+instance IsGObject SVGTextPathElement where
+  typeGType _ = gTypeSVGTextPathElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SVGTextPathElement\"]" gTypeSVGTextPathElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SVGTextPositioningElement".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.SVGTextContentElement"
+--     * "GHCJS.DOM.SVGGraphicsElement"
+--     * "GHCJS.DOM.SVGElement"
+--     * "GHCJS.DOM.Element"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SVGTextPositioningElement Mozilla SVGTextPositioningElement documentation>
+newtype SVGTextPositioningElement = SVGTextPositioningElement { unSVGTextPositioningElement :: JSVal }
+
+instance Eq (SVGTextPositioningElement) where
+  (SVGTextPositioningElement a) == (SVGTextPositioningElement b) = js_eq a b
+
+instance PToJSVal SVGTextPositioningElement where
+  pToJSVal = unSVGTextPositioningElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SVGTextPositioningElement where
+  pFromJSVal = SVGTextPositioningElement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SVGTextPositioningElement where
+  toJSVal = return . unSVGTextPositioningElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SVGTextPositioningElement where
+  fromJSVal = return . fmap SVGTextPositioningElement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+class IsSVGTextContentElement o => IsSVGTextPositioningElement o
+toSVGTextPositioningElement :: IsSVGTextPositioningElement o => o -> SVGTextPositioningElement
+toSVGTextPositioningElement = SVGTextPositioningElement . coerce
+
+instance IsSVGTextPositioningElement SVGTextPositioningElement
+instance IsSVGTextContentElement SVGTextPositioningElement
+instance IsSVGGraphicsElement SVGTextPositioningElement
+instance IsSVGElement SVGTextPositioningElement
+instance IsElement SVGTextPositioningElement
+instance IsNode SVGTextPositioningElement
+instance IsEventTarget SVGTextPositioningElement
+instance IsGObject SVGTextPositioningElement where
+  typeGType _ = gTypeSVGTextPositioningElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SVGTextPositioningElement\"]" gTypeSVGTextPositioningElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SVGTitleElement".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.SVGElement"
+--     * "GHCJS.DOM.Element"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SVGTitleElement Mozilla SVGTitleElement documentation>
+newtype SVGTitleElement = SVGTitleElement { unSVGTitleElement :: JSVal }
+
+instance Eq (SVGTitleElement) where
+  (SVGTitleElement a) == (SVGTitleElement b) = js_eq a b
+
+instance PToJSVal SVGTitleElement where
+  pToJSVal = unSVGTitleElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SVGTitleElement where
+  pFromJSVal = SVGTitleElement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SVGTitleElement where
+  toJSVal = return . unSVGTitleElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SVGTitleElement where
+  fromJSVal = return . fmap SVGTitleElement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsSVGElement SVGTitleElement
+instance IsElement SVGTitleElement
+instance IsNode SVGTitleElement
+instance IsEventTarget SVGTitleElement
+instance IsGObject SVGTitleElement where
+  typeGType _ = gTypeSVGTitleElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SVGTitleElement\"]" gTypeSVGTitleElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SVGTransform".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SVGTransform Mozilla SVGTransform documentation>
+newtype SVGTransform = SVGTransform { unSVGTransform :: JSVal }
+
+instance Eq (SVGTransform) where
+  (SVGTransform a) == (SVGTransform b) = js_eq a b
+
+instance PToJSVal SVGTransform where
+  pToJSVal = unSVGTransform
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SVGTransform where
+  pFromJSVal = SVGTransform
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SVGTransform where
+  toJSVal = return . unSVGTransform
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SVGTransform where
+  fromJSVal = return . fmap SVGTransform . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject SVGTransform where
+  typeGType _ = gTypeSVGTransform
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SVGTransform\"]" gTypeSVGTransform :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SVGTransformList".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SVGTransformList Mozilla SVGTransformList documentation>
+newtype SVGTransformList = SVGTransformList { unSVGTransformList :: JSVal }
+
+instance Eq (SVGTransformList) where
+  (SVGTransformList a) == (SVGTransformList b) = js_eq a b
+
+instance PToJSVal SVGTransformList where
+  pToJSVal = unSVGTransformList
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SVGTransformList where
+  pFromJSVal = SVGTransformList
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SVGTransformList where
+  toJSVal = return . unSVGTransformList
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SVGTransformList where
+  fromJSVal = return . fmap SVGTransformList . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject SVGTransformList where
+  typeGType _ = gTypeSVGTransformList
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SVGTransformList\"]" gTypeSVGTransformList :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SVGURIReference".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SVGURIReference Mozilla SVGURIReference documentation>
+newtype SVGURIReference = SVGURIReference { unSVGURIReference :: JSVal }
+
+instance Eq (SVGURIReference) where
+  (SVGURIReference a) == (SVGURIReference b) = js_eq a b
+
+instance PToJSVal SVGURIReference where
+  pToJSVal = unSVGURIReference
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SVGURIReference where
+  pFromJSVal = SVGURIReference
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SVGURIReference where
+  toJSVal = return . unSVGURIReference
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SVGURIReference where
+  fromJSVal = return . fmap SVGURIReference . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject SVGURIReference where
+  typeGType _ = gTypeSVGURIReference
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SVGURIReference\"]" gTypeSVGURIReference :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SVGUnitTypes".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SVGUnitTypes Mozilla SVGUnitTypes documentation>
+newtype SVGUnitTypes = SVGUnitTypes { unSVGUnitTypes :: JSVal }
+
+instance Eq (SVGUnitTypes) where
+  (SVGUnitTypes a) == (SVGUnitTypes b) = js_eq a b
+
+instance PToJSVal SVGUnitTypes where
+  pToJSVal = unSVGUnitTypes
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SVGUnitTypes where
+  pFromJSVal = SVGUnitTypes
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SVGUnitTypes where
+  toJSVal = return . unSVGUnitTypes
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SVGUnitTypes where
+  fromJSVal = return . fmap SVGUnitTypes . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject SVGUnitTypes where
+  typeGType _ = gTypeSVGUnitTypes
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SVGUnitTypes\"]" gTypeSVGUnitTypes :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SVGUseElement".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.SVGGraphicsElement"
+--     * "GHCJS.DOM.SVGElement"
+--     * "GHCJS.DOM.Element"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SVGUseElement Mozilla SVGUseElement documentation>
+newtype SVGUseElement = SVGUseElement { unSVGUseElement :: JSVal }
+
+instance Eq (SVGUseElement) where
+  (SVGUseElement a) == (SVGUseElement b) = js_eq a b
+
+instance PToJSVal SVGUseElement where
+  pToJSVal = unSVGUseElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SVGUseElement where
+  pFromJSVal = SVGUseElement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SVGUseElement where
+  toJSVal = return . unSVGUseElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SVGUseElement where
+  fromJSVal = return . fmap SVGUseElement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsSVGGraphicsElement SVGUseElement
+instance IsSVGElement SVGUseElement
+instance IsElement SVGUseElement
+instance IsNode SVGUseElement
+instance IsEventTarget SVGUseElement
+instance IsGObject SVGUseElement where
+  typeGType _ = gTypeSVGUseElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SVGUseElement\"]" gTypeSVGUseElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SVGVKernElement".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.SVGElement"
+--     * "GHCJS.DOM.Element"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SVGVKernElement Mozilla SVGVKernElement documentation>
+newtype SVGVKernElement = SVGVKernElement { unSVGVKernElement :: JSVal }
+
+instance Eq (SVGVKernElement) where
+  (SVGVKernElement a) == (SVGVKernElement b) = js_eq a b
+
+instance PToJSVal SVGVKernElement where
+  pToJSVal = unSVGVKernElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SVGVKernElement where
+  pFromJSVal = SVGVKernElement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SVGVKernElement where
+  toJSVal = return . unSVGVKernElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SVGVKernElement where
+  fromJSVal = return . fmap SVGVKernElement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsSVGElement SVGVKernElement
+instance IsElement SVGVKernElement
+instance IsNode SVGVKernElement
+instance IsEventTarget SVGVKernElement
+instance IsGObject SVGVKernElement where
+  typeGType _ = gTypeSVGVKernElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SVGVKernElement\"]" gTypeSVGVKernElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SVGViewElement".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.SVGElement"
+--     * "GHCJS.DOM.Element"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SVGViewElement Mozilla SVGViewElement documentation>
+newtype SVGViewElement = SVGViewElement { unSVGViewElement :: JSVal }
+
+instance Eq (SVGViewElement) where
+  (SVGViewElement a) == (SVGViewElement b) = js_eq a b
+
+instance PToJSVal SVGViewElement where
+  pToJSVal = unSVGViewElement
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SVGViewElement where
+  pFromJSVal = SVGViewElement
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SVGViewElement where
+  toJSVal = return . unSVGViewElement
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SVGViewElement where
+  fromJSVal = return . fmap SVGViewElement . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsSVGElement SVGViewElement
+instance IsElement SVGViewElement
+instance IsNode SVGViewElement
+instance IsEventTarget SVGViewElement
+instance IsGObject SVGViewElement where
+  typeGType _ = gTypeSVGViewElement
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SVGViewElement\"]" gTypeSVGViewElement :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SVGViewSpec".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SVGViewSpec Mozilla SVGViewSpec documentation>
+newtype SVGViewSpec = SVGViewSpec { unSVGViewSpec :: JSVal }
+
+instance Eq (SVGViewSpec) where
+  (SVGViewSpec a) == (SVGViewSpec b) = js_eq a b
+
+instance PToJSVal SVGViewSpec where
+  pToJSVal = unSVGViewSpec
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SVGViewSpec where
+  pFromJSVal = SVGViewSpec
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SVGViewSpec where
+  toJSVal = return . unSVGViewSpec
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SVGViewSpec where
+  fromJSVal = return . fmap SVGViewSpec . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject SVGViewSpec where
+  typeGType _ = gTypeSVGViewSpec
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SVGViewSpec\"]" gTypeSVGViewSpec :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SVGZoomAndPan".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SVGZoomAndPan Mozilla SVGZoomAndPan documentation>
+newtype SVGZoomAndPan = SVGZoomAndPan { unSVGZoomAndPan :: JSVal }
+
+instance Eq (SVGZoomAndPan) where
+  (SVGZoomAndPan a) == (SVGZoomAndPan b) = js_eq a b
+
+instance PToJSVal SVGZoomAndPan where
+  pToJSVal = unSVGZoomAndPan
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SVGZoomAndPan where
+  pFromJSVal = SVGZoomAndPan
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SVGZoomAndPan where
+  toJSVal = return . unSVGZoomAndPan
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SVGZoomAndPan where
+  fromJSVal = return . fmap SVGZoomAndPan . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject SVGZoomAndPan where
+  typeGType _ = gTypeSVGZoomAndPan
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SVGZoomAndPan\"]" gTypeSVGZoomAndPan :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SVGZoomEvent".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.UIEvent"
+--     * "GHCJS.DOM.Event"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SVGZoomEvent Mozilla SVGZoomEvent documentation>
+newtype SVGZoomEvent = SVGZoomEvent { unSVGZoomEvent :: JSVal }
+
+instance Eq (SVGZoomEvent) where
+  (SVGZoomEvent a) == (SVGZoomEvent b) = js_eq a b
+
+instance PToJSVal SVGZoomEvent where
+  pToJSVal = unSVGZoomEvent
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SVGZoomEvent where
+  pFromJSVal = SVGZoomEvent
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SVGZoomEvent where
+  toJSVal = return . unSVGZoomEvent
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SVGZoomEvent where
+  fromJSVal = return . fmap SVGZoomEvent . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsUIEvent SVGZoomEvent
+instance IsEvent SVGZoomEvent
+instance IsGObject SVGZoomEvent where
+  typeGType _ = gTypeSVGZoomEvent
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SVGZoomEvent\"]" gTypeSVGZoomEvent :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.Screen".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/Screen Mozilla Screen documentation>
+newtype Screen = Screen { unScreen :: JSVal }
+
+instance Eq (Screen) where
+  (Screen a) == (Screen b) = js_eq a b
+
+instance PToJSVal Screen where
+  pToJSVal = unScreen
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal Screen where
+  pFromJSVal = Screen
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal Screen where
+  toJSVal = return . unScreen
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal Screen where
+  fromJSVal = return . fmap Screen . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject Screen where
+  typeGType _ = gTypeScreen
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"Screen\"]" gTypeScreen :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.ScriptProcessorNode".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.AudioNode"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/ScriptProcessorNode Mozilla ScriptProcessorNode documentation>
+newtype ScriptProcessorNode = ScriptProcessorNode { unScriptProcessorNode :: JSVal }
+
+instance Eq (ScriptProcessorNode) where
+  (ScriptProcessorNode a) == (ScriptProcessorNode b) = js_eq a b
+
+instance PToJSVal ScriptProcessorNode where
+  pToJSVal = unScriptProcessorNode
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal ScriptProcessorNode where
+  pFromJSVal = ScriptProcessorNode
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal ScriptProcessorNode where
+  toJSVal = return . unScriptProcessorNode
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal ScriptProcessorNode where
+  fromJSVal = return . fmap ScriptProcessorNode . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsAudioNode ScriptProcessorNode
+instance IsEventTarget ScriptProcessorNode
+instance IsGObject ScriptProcessorNode where
+  typeGType _ = gTypeScriptProcessorNode
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"ScriptProcessorNode\"]" gTypeScriptProcessorNode :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.ScriptProfile".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/ScriptProfile Mozilla ScriptProfile documentation>
+newtype ScriptProfile = ScriptProfile { unScriptProfile :: JSVal }
+
+instance Eq (ScriptProfile) where
+  (ScriptProfile a) == (ScriptProfile b) = js_eq a b
+
+instance PToJSVal ScriptProfile where
+  pToJSVal = unScriptProfile
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal ScriptProfile where
+  pFromJSVal = ScriptProfile
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal ScriptProfile where
+  toJSVal = return . unScriptProfile
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal ScriptProfile where
+  fromJSVal = return . fmap ScriptProfile . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject ScriptProfile where
+  typeGType _ = gTypeScriptProfile
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"ScriptProfile\"]" gTypeScriptProfile :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.ScriptProfileNode".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/ScriptProfileNode Mozilla ScriptProfileNode documentation>
+newtype ScriptProfileNode = ScriptProfileNode { unScriptProfileNode :: JSVal }
+
+instance Eq (ScriptProfileNode) where
+  (ScriptProfileNode a) == (ScriptProfileNode b) = js_eq a b
+
+instance PToJSVal ScriptProfileNode where
+  pToJSVal = unScriptProfileNode
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal ScriptProfileNode where
+  pFromJSVal = ScriptProfileNode
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal ScriptProfileNode where
+  toJSVal = return . unScriptProfileNode
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal ScriptProfileNode where
+  fromJSVal = return . fmap ScriptProfileNode . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject ScriptProfileNode where
+  typeGType _ = gTypeScriptProfileNode
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"ScriptProfileNode\"]" gTypeScriptProfileNode :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SecurityPolicy".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SecurityPolicy Mozilla SecurityPolicy documentation>
+newtype SecurityPolicy = SecurityPolicy { unSecurityPolicy :: JSVal }
+
+instance Eq (SecurityPolicy) where
+  (SecurityPolicy a) == (SecurityPolicy b) = js_eq a b
+
+instance PToJSVal SecurityPolicy where
+  pToJSVal = unSecurityPolicy
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SecurityPolicy where
+  pFromJSVal = SecurityPolicy
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SecurityPolicy where
+  toJSVal = return . unSecurityPolicy
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SecurityPolicy where
+  fromJSVal = return . fmap SecurityPolicy . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject SecurityPolicy where
+  typeGType _ = gTypeSecurityPolicy
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SecurityPolicy\"]" gTypeSecurityPolicy :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SecurityPolicyViolationEvent".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.Event"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SecurityPolicyViolationEvent Mozilla SecurityPolicyViolationEvent documentation>
+newtype SecurityPolicyViolationEvent = SecurityPolicyViolationEvent { unSecurityPolicyViolationEvent :: JSVal }
+
+instance Eq (SecurityPolicyViolationEvent) where
+  (SecurityPolicyViolationEvent a) == (SecurityPolicyViolationEvent b) = js_eq a b
+
+instance PToJSVal SecurityPolicyViolationEvent where
+  pToJSVal = unSecurityPolicyViolationEvent
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SecurityPolicyViolationEvent where
+  pFromJSVal = SecurityPolicyViolationEvent
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SecurityPolicyViolationEvent where
+  toJSVal = return . unSecurityPolicyViolationEvent
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SecurityPolicyViolationEvent where
+  fromJSVal = return . fmap SecurityPolicyViolationEvent . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsEvent SecurityPolicyViolationEvent
+instance IsGObject SecurityPolicyViolationEvent where
+  typeGType _ = gTypeSecurityPolicyViolationEvent
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SecurityPolicyViolationEvent\"]" gTypeSecurityPolicyViolationEvent :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.Selection".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/Selection Mozilla Selection documentation>
+newtype Selection = Selection { unSelection :: JSVal }
+
+instance Eq (Selection) where
+  (Selection a) == (Selection b) = js_eq a b
+
+instance PToJSVal Selection where
+  pToJSVal = unSelection
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal Selection where
+  pFromJSVal = Selection
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal Selection where
+  toJSVal = return . unSelection
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal Selection where
+  fromJSVal = return . fmap Selection . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject Selection where
+  typeGType _ = gTypeSelection
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"Selection\"]" gTypeSelection :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SourceBuffer".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SourceBuffer Mozilla SourceBuffer documentation>
+newtype SourceBuffer = SourceBuffer { unSourceBuffer :: JSVal }
+
+instance Eq (SourceBuffer) where
+  (SourceBuffer a) == (SourceBuffer b) = js_eq a b
+
+instance PToJSVal SourceBuffer where
+  pToJSVal = unSourceBuffer
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SourceBuffer where
+  pFromJSVal = SourceBuffer
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SourceBuffer where
+  toJSVal = return . unSourceBuffer
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SourceBuffer where
+  fromJSVal = return . fmap SourceBuffer . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsEventTarget SourceBuffer
+instance IsGObject SourceBuffer where
+  typeGType _ = gTypeSourceBuffer
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SourceBuffer\"]" gTypeSourceBuffer :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SourceBufferList".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SourceBufferList Mozilla SourceBufferList documentation>
+newtype SourceBufferList = SourceBufferList { unSourceBufferList :: JSVal }
+
+instance Eq (SourceBufferList) where
+  (SourceBufferList a) == (SourceBufferList b) = js_eq a b
+
+instance PToJSVal SourceBufferList where
+  pToJSVal = unSourceBufferList
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SourceBufferList where
+  pFromJSVal = SourceBufferList
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SourceBufferList where
+  toJSVal = return . unSourceBufferList
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SourceBufferList where
+  fromJSVal = return . fmap SourceBufferList . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsEventTarget SourceBufferList
+instance IsGObject SourceBufferList where
+  typeGType _ = gTypeSourceBufferList
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SourceBufferList\"]" gTypeSourceBufferList :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SourceInfo".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SourceInfo Mozilla SourceInfo documentation>
+newtype SourceInfo = SourceInfo { unSourceInfo :: JSVal }
+
+instance Eq (SourceInfo) where
+  (SourceInfo a) == (SourceInfo b) = js_eq a b
+
+instance PToJSVal SourceInfo where
+  pToJSVal = unSourceInfo
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SourceInfo where
+  pFromJSVal = SourceInfo
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SourceInfo where
+  toJSVal = return . unSourceInfo
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SourceInfo where
+  fromJSVal = return . fmap SourceInfo . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject SourceInfo where
+  typeGType _ = gTypeSourceInfo
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SourceInfo\"]" gTypeSourceInfo :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SpeechSynthesis".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SpeechSynthesis Mozilla SpeechSynthesis documentation>
+newtype SpeechSynthesis = SpeechSynthesis { unSpeechSynthesis :: JSVal }
+
+instance Eq (SpeechSynthesis) where
+  (SpeechSynthesis a) == (SpeechSynthesis b) = js_eq a b
+
+instance PToJSVal SpeechSynthesis where
+  pToJSVal = unSpeechSynthesis
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SpeechSynthesis where
+  pFromJSVal = SpeechSynthesis
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SpeechSynthesis where
+  toJSVal = return . unSpeechSynthesis
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SpeechSynthesis where
+  fromJSVal = return . fmap SpeechSynthesis . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject SpeechSynthesis where
+  typeGType _ = gTypeSpeechSynthesis
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SpeechSynthesis\"]" gTypeSpeechSynthesis :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SpeechSynthesisEvent".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.Event"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SpeechSynthesisEvent Mozilla SpeechSynthesisEvent documentation>
+newtype SpeechSynthesisEvent = SpeechSynthesisEvent { unSpeechSynthesisEvent :: JSVal }
+
+instance Eq (SpeechSynthesisEvent) where
+  (SpeechSynthesisEvent a) == (SpeechSynthesisEvent b) = js_eq a b
+
+instance PToJSVal SpeechSynthesisEvent where
+  pToJSVal = unSpeechSynthesisEvent
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SpeechSynthesisEvent where
+  pFromJSVal = SpeechSynthesisEvent
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SpeechSynthesisEvent where
+  toJSVal = return . unSpeechSynthesisEvent
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SpeechSynthesisEvent where
+  fromJSVal = return . fmap SpeechSynthesisEvent . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsEvent SpeechSynthesisEvent
+instance IsGObject SpeechSynthesisEvent where
+  typeGType _ = gTypeSpeechSynthesisEvent
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SpeechSynthesisEvent\"]" gTypeSpeechSynthesisEvent :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SpeechSynthesisUtterance".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SpeechSynthesisUtterance Mozilla SpeechSynthesisUtterance documentation>
+newtype SpeechSynthesisUtterance = SpeechSynthesisUtterance { unSpeechSynthesisUtterance :: JSVal }
+
+instance Eq (SpeechSynthesisUtterance) where
+  (SpeechSynthesisUtterance a) == (SpeechSynthesisUtterance b) = js_eq a b
+
+instance PToJSVal SpeechSynthesisUtterance where
+  pToJSVal = unSpeechSynthesisUtterance
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SpeechSynthesisUtterance where
+  pFromJSVal = SpeechSynthesisUtterance
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SpeechSynthesisUtterance where
+  toJSVal = return . unSpeechSynthesisUtterance
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SpeechSynthesisUtterance where
+  fromJSVal = return . fmap SpeechSynthesisUtterance . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsEventTarget SpeechSynthesisUtterance
+instance IsGObject SpeechSynthesisUtterance where
+  typeGType _ = gTypeSpeechSynthesisUtterance
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SpeechSynthesisUtterance\"]" gTypeSpeechSynthesisUtterance :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SpeechSynthesisVoice".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/SpeechSynthesisVoice Mozilla SpeechSynthesisVoice documentation>
+newtype SpeechSynthesisVoice = SpeechSynthesisVoice { unSpeechSynthesisVoice :: JSVal }
+
+instance Eq (SpeechSynthesisVoice) where
+  (SpeechSynthesisVoice a) == (SpeechSynthesisVoice b) = js_eq a b
+
+instance PToJSVal SpeechSynthesisVoice where
+  pToJSVal = unSpeechSynthesisVoice
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SpeechSynthesisVoice where
+  pFromJSVal = SpeechSynthesisVoice
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SpeechSynthesisVoice where
+  toJSVal = return . unSpeechSynthesisVoice
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SpeechSynthesisVoice where
+  fromJSVal = return . fmap SpeechSynthesisVoice . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject SpeechSynthesisVoice where
+  typeGType _ = gTypeSpeechSynthesisVoice
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"SpeechSynthesisVoice\"]" gTypeSpeechSynthesisVoice :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.Storage".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/Storage Mozilla Storage documentation>
+newtype Storage = Storage { unStorage :: JSVal }
+
+instance Eq (Storage) where
+  (Storage a) == (Storage b) = js_eq a b
+
+instance PToJSVal Storage where
+  pToJSVal = unStorage
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal Storage where
+  pFromJSVal = Storage
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal Storage where
+  toJSVal = return . unStorage
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal Storage where
+  fromJSVal = return . fmap Storage . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject Storage where
+  typeGType _ = gTypeStorage
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"Storage\"]" gTypeStorage :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.StorageEvent".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.Event"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/StorageEvent Mozilla StorageEvent documentation>
+newtype StorageEvent = StorageEvent { unStorageEvent :: JSVal }
+
+instance Eq (StorageEvent) where
+  (StorageEvent a) == (StorageEvent b) = js_eq a b
+
+instance PToJSVal StorageEvent where
+  pToJSVal = unStorageEvent
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal StorageEvent where
+  pFromJSVal = StorageEvent
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal StorageEvent where
+  toJSVal = return . unStorageEvent
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal StorageEvent where
+  fromJSVal = return . fmap StorageEvent . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsEvent StorageEvent
+instance IsGObject StorageEvent where
+  typeGType _ = gTypeStorageEvent
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"StorageEvent\"]" gTypeStorageEvent :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.StorageInfo".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/StorageInfo Mozilla StorageInfo documentation>
+newtype StorageInfo = StorageInfo { unStorageInfo :: JSVal }
+
+instance Eq (StorageInfo) where
+  (StorageInfo a) == (StorageInfo b) = js_eq a b
+
+instance PToJSVal StorageInfo where
+  pToJSVal = unStorageInfo
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal StorageInfo where
+  pFromJSVal = StorageInfo
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal StorageInfo where
+  toJSVal = return . unStorageInfo
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal StorageInfo where
+  fromJSVal = return . fmap StorageInfo . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject StorageInfo where
+  typeGType _ = gTypeStorageInfo
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"StorageInfo\"]" gTypeStorageInfo :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.StorageQuota".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/StorageQuota Mozilla StorageQuota documentation>
+newtype StorageQuota = StorageQuota { unStorageQuota :: JSVal }
+
+instance Eq (StorageQuota) where
+  (StorageQuota a) == (StorageQuota b) = js_eq a b
+
+instance PToJSVal StorageQuota where
+  pToJSVal = unStorageQuota
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal StorageQuota where
+  pFromJSVal = StorageQuota
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal StorageQuota where
+  toJSVal = return . unStorageQuota
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal StorageQuota where
+  fromJSVal = return . fmap StorageQuota . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject StorageQuota where
+  typeGType _ = gTypeStorageQuota
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"StorageQuota\"]" gTypeStorageQuota :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.StyleMedia".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/StyleMedia Mozilla StyleMedia documentation>
+newtype StyleMedia = StyleMedia { unStyleMedia :: JSVal }
+
+instance Eq (StyleMedia) where
+  (StyleMedia a) == (StyleMedia b) = js_eq a b
+
+instance PToJSVal StyleMedia where
+  pToJSVal = unStyleMedia
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal StyleMedia where
+  pFromJSVal = StyleMedia
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal StyleMedia where
+  toJSVal = return . unStyleMedia
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal StyleMedia where
+  fromJSVal = return . fmap StyleMedia . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject StyleMedia where
+  typeGType _ = gTypeStyleMedia
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"StyleMedia\"]" gTypeStyleMedia :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.StyleSheet".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/StyleSheet Mozilla StyleSheet documentation>
+newtype StyleSheet = StyleSheet { unStyleSheet :: JSVal }
+
+instance Eq (StyleSheet) where
+  (StyleSheet a) == (StyleSheet b) = js_eq a b
+
+instance PToJSVal StyleSheet where
+  pToJSVal = unStyleSheet
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal StyleSheet where
+  pFromJSVal = StyleSheet
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal StyleSheet where
+  toJSVal = return . unStyleSheet
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal StyleSheet where
+  fromJSVal = return . fmap StyleSheet . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+class IsGObject o => IsStyleSheet o
+toStyleSheet :: IsStyleSheet o => o -> StyleSheet
+toStyleSheet = StyleSheet . coerce
+
+instance IsStyleSheet StyleSheet
+instance IsGObject StyleSheet where
+  typeGType _ = gTypeStyleSheet
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"StyleSheet\"]" gTypeStyleSheet :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.StyleSheetList".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/StyleSheetList Mozilla StyleSheetList documentation>
+newtype StyleSheetList = StyleSheetList { unStyleSheetList :: JSVal }
+
+instance Eq (StyleSheetList) where
+  (StyleSheetList a) == (StyleSheetList b) = js_eq a b
+
+instance PToJSVal StyleSheetList where
+  pToJSVal = unStyleSheetList
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal StyleSheetList where
+  pFromJSVal = StyleSheetList
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal StyleSheetList where
+  toJSVal = return . unStyleSheetList
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal StyleSheetList where
+  fromJSVal = return . fmap StyleSheetList . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject StyleSheetList where
+  typeGType _ = gTypeStyleSheetList
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"StyleSheetList\"]" gTypeStyleSheetList :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.SubtleCrypto".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/WebKitSubtleCrypto Mozilla WebKitSubtleCrypto documentation>
+newtype SubtleCrypto = SubtleCrypto { unSubtleCrypto :: JSVal }
+
+instance Eq (SubtleCrypto) where
+  (SubtleCrypto a) == (SubtleCrypto b) = js_eq a b
+
+instance PToJSVal SubtleCrypto where
+  pToJSVal = unSubtleCrypto
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal SubtleCrypto where
+  pFromJSVal = SubtleCrypto
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal SubtleCrypto where
+  toJSVal = return . unSubtleCrypto
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal SubtleCrypto where
+  fromJSVal = return . fmap SubtleCrypto . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject SubtleCrypto where
+  typeGType _ = gTypeSubtleCrypto
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"WebKitSubtleCrypto\"]" gTypeSubtleCrypto :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.Text".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.CharacterData"
+--     * "GHCJS.DOM.Node"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/Text Mozilla Text documentation>
+newtype Text = Text { unText :: JSVal }
+
+instance Eq (Text) where
+  (Text a) == (Text b) = js_eq a b
+
+instance PToJSVal Text where
+  pToJSVal = unText
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal Text where
+  pFromJSVal = Text
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal Text where
+  toJSVal = return . unText
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal Text where
+  fromJSVal = return . fmap Text . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+class IsCharacterData o => IsText o
+toText :: IsText o => o -> Text
+toText = Text . coerce
+
+instance IsText Text
+instance IsCharacterData Text
+instance IsNode Text
+instance IsEventTarget Text
+instance IsGObject Text where
+  typeGType _ = gTypeText
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"Text\"]" gTypeText :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.TextEvent".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.UIEvent"
+--     * "GHCJS.DOM.Event"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/TextEvent Mozilla TextEvent documentation>
+newtype TextEvent = TextEvent { unTextEvent :: JSVal }
+
+instance Eq (TextEvent) where
+  (TextEvent a) == (TextEvent b) = js_eq a b
+
+instance PToJSVal TextEvent where
+  pToJSVal = unTextEvent
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal TextEvent where
+  pFromJSVal = TextEvent
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal TextEvent where
+  toJSVal = return . unTextEvent
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal TextEvent where
+  fromJSVal = return . fmap TextEvent . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsUIEvent TextEvent
+instance IsEvent TextEvent
+instance IsGObject TextEvent where
+  typeGType _ = gTypeTextEvent
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"TextEvent\"]" gTypeTextEvent :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.TextMetrics".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/TextMetrics Mozilla TextMetrics documentation>
+newtype TextMetrics = TextMetrics { unTextMetrics :: JSVal }
+
+instance Eq (TextMetrics) where
+  (TextMetrics a) == (TextMetrics b) = js_eq a b
+
+instance PToJSVal TextMetrics where
+  pToJSVal = unTextMetrics
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal TextMetrics where
+  pFromJSVal = TextMetrics
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal TextMetrics where
+  toJSVal = return . unTextMetrics
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal TextMetrics where
+  fromJSVal = return . fmap TextMetrics . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject TextMetrics where
+  typeGType _ = gTypeTextMetrics
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"TextMetrics\"]" gTypeTextMetrics :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.TextTrack".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/TextTrack Mozilla TextTrack documentation>
+newtype TextTrack = TextTrack { unTextTrack :: JSVal }
+
+instance Eq (TextTrack) where
+  (TextTrack a) == (TextTrack b) = js_eq a b
+
+instance PToJSVal TextTrack where
+  pToJSVal = unTextTrack
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal TextTrack where
+  pFromJSVal = TextTrack
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal TextTrack where
+  toJSVal = return . unTextTrack
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal TextTrack where
+  fromJSVal = return . fmap TextTrack . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsEventTarget TextTrack
+instance IsGObject TextTrack where
+  typeGType _ = gTypeTextTrack
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"TextTrack\"]" gTypeTextTrack :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.TextTrackCue".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/TextTrackCue Mozilla TextTrackCue documentation>
+newtype TextTrackCue = TextTrackCue { unTextTrackCue :: JSVal }
+
+instance Eq (TextTrackCue) where
+  (TextTrackCue a) == (TextTrackCue b) = js_eq a b
+
+instance PToJSVal TextTrackCue where
+  pToJSVal = unTextTrackCue
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal TextTrackCue where
+  pFromJSVal = TextTrackCue
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal TextTrackCue where
+  toJSVal = return . unTextTrackCue
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal TextTrackCue where
+  fromJSVal = return . fmap TextTrackCue . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+class IsEventTarget o => IsTextTrackCue o
+toTextTrackCue :: IsTextTrackCue o => o -> TextTrackCue
+toTextTrackCue = TextTrackCue . coerce
+
+instance IsTextTrackCue TextTrackCue
+instance IsEventTarget TextTrackCue
+instance IsGObject TextTrackCue where
+  typeGType _ = gTypeTextTrackCue
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"TextTrackCue\"]" gTypeTextTrackCue :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.TextTrackCueList".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/TextTrackCueList Mozilla TextTrackCueList documentation>
+newtype TextTrackCueList = TextTrackCueList { unTextTrackCueList :: JSVal }
+
+instance Eq (TextTrackCueList) where
+  (TextTrackCueList a) == (TextTrackCueList b) = js_eq a b
+
+instance PToJSVal TextTrackCueList where
+  pToJSVal = unTextTrackCueList
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal TextTrackCueList where
+  pFromJSVal = TextTrackCueList
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal TextTrackCueList where
+  toJSVal = return . unTextTrackCueList
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal TextTrackCueList where
+  fromJSVal = return . fmap TextTrackCueList . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject TextTrackCueList where
+  typeGType _ = gTypeTextTrackCueList
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"TextTrackCueList\"]" gTypeTextTrackCueList :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.TextTrackList".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/TextTrackList Mozilla TextTrackList documentation>
+newtype TextTrackList = TextTrackList { unTextTrackList :: JSVal }
+
+instance Eq (TextTrackList) where
+  (TextTrackList a) == (TextTrackList b) = js_eq a b
+
+instance PToJSVal TextTrackList where
+  pToJSVal = unTextTrackList
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal TextTrackList where
+  pFromJSVal = TextTrackList
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal TextTrackList where
+  toJSVal = return . unTextTrackList
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal TextTrackList where
+  fromJSVal = return . fmap TextTrackList . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsEventTarget TextTrackList
+instance IsGObject TextTrackList where
+  typeGType _ = gTypeTextTrackList
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"TextTrackList\"]" gTypeTextTrackList :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.TimeRanges".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/TimeRanges Mozilla TimeRanges documentation>
+newtype TimeRanges = TimeRanges { unTimeRanges :: JSVal }
+
+instance Eq (TimeRanges) where
+  (TimeRanges a) == (TimeRanges b) = js_eq a b
+
+instance PToJSVal TimeRanges where
+  pToJSVal = unTimeRanges
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal TimeRanges where
+  pFromJSVal = TimeRanges
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal TimeRanges where
+  toJSVal = return . unTimeRanges
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal TimeRanges where
+  fromJSVal = return . fmap TimeRanges . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject TimeRanges where
+  typeGType _ = gTypeTimeRanges
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"TimeRanges\"]" gTypeTimeRanges :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.Touch".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/Touch Mozilla Touch documentation>
+newtype Touch = Touch { unTouch :: JSVal }
+
+instance Eq (Touch) where
+  (Touch a) == (Touch b) = js_eq a b
+
+instance PToJSVal Touch where
+  pToJSVal = unTouch
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal Touch where
+  pFromJSVal = Touch
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal Touch where
+  toJSVal = return . unTouch
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal Touch where
+  fromJSVal = return . fmap Touch . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject Touch where
+  typeGType _ = gTypeTouch
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"Touch\"]" gTypeTouch :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.TouchEvent".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.UIEvent"
+--     * "GHCJS.DOM.Event"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/TouchEvent Mozilla TouchEvent documentation>
+newtype TouchEvent = TouchEvent { unTouchEvent :: JSVal }
+
+instance Eq (TouchEvent) where
+  (TouchEvent a) == (TouchEvent b) = js_eq a b
+
+instance PToJSVal TouchEvent where
+  pToJSVal = unTouchEvent
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal TouchEvent where
+  pFromJSVal = TouchEvent
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal TouchEvent where
+  toJSVal = return . unTouchEvent
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal TouchEvent where
+  fromJSVal = return . fmap TouchEvent . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsUIEvent TouchEvent
+instance IsEvent TouchEvent
+instance IsGObject TouchEvent where
+  typeGType _ = gTypeTouchEvent
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"TouchEvent\"]" gTypeTouchEvent :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.TouchList".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/TouchList Mozilla TouchList documentation>
+newtype TouchList = TouchList { unTouchList :: JSVal }
+
+instance Eq (TouchList) where
+  (TouchList a) == (TouchList b) = js_eq a b
+
+instance PToJSVal TouchList where
+  pToJSVal = unTouchList
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal TouchList where
+  pFromJSVal = TouchList
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal TouchList where
+  toJSVal = return . unTouchList
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal TouchList where
+  fromJSVal = return . fmap TouchList . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject TouchList where
+  typeGType _ = gTypeTouchList
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"TouchList\"]" gTypeTouchList :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.TrackEvent".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.Event"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/TrackEvent Mozilla TrackEvent documentation>
+newtype TrackEvent = TrackEvent { unTrackEvent :: JSVal }
+
+instance Eq (TrackEvent) where
+  (TrackEvent a) == (TrackEvent b) = js_eq a b
+
+instance PToJSVal TrackEvent where
+  pToJSVal = unTrackEvent
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal TrackEvent where
+  pFromJSVal = TrackEvent
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal TrackEvent where
+  toJSVal = return . unTrackEvent
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal TrackEvent where
+  fromJSVal = return . fmap TrackEvent . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsEvent TrackEvent
+instance IsGObject TrackEvent where
+  typeGType _ = gTypeTrackEvent
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"TrackEvent\"]" gTypeTrackEvent :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.TransitionEvent".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.Event"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/TransitionEvent Mozilla TransitionEvent documentation>
+newtype TransitionEvent = TransitionEvent { unTransitionEvent :: JSVal }
+
+instance Eq (TransitionEvent) where
+  (TransitionEvent a) == (TransitionEvent b) = js_eq a b
+
+instance PToJSVal TransitionEvent where
+  pToJSVal = unTransitionEvent
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal TransitionEvent where
+  pFromJSVal = TransitionEvent
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal TransitionEvent where
+  toJSVal = return . unTransitionEvent
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal TransitionEvent where
+  fromJSVal = return . fmap TransitionEvent . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsEvent TransitionEvent
+instance IsGObject TransitionEvent where
+  typeGType _ = gTypeTransitionEvent
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"TransitionEvent\"]" gTypeTransitionEvent :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.TreeWalker".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/TreeWalker Mozilla TreeWalker documentation>
+newtype TreeWalker = TreeWalker { unTreeWalker :: JSVal }
+
+instance Eq (TreeWalker) where
+  (TreeWalker a) == (TreeWalker b) = js_eq a b
+
+instance PToJSVal TreeWalker where
+  pToJSVal = unTreeWalker
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal TreeWalker where
+  pFromJSVal = TreeWalker
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal TreeWalker where
+  toJSVal = return . unTreeWalker
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal TreeWalker where
+  fromJSVal = return . fmap TreeWalker . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject TreeWalker where
+  typeGType _ = gTypeTreeWalker
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"TreeWalker\"]" gTypeTreeWalker :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.TypeConversions".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/TypeConversions Mozilla TypeConversions documentation>
+newtype TypeConversions = TypeConversions { unTypeConversions :: JSVal }
+
+instance Eq (TypeConversions) where
+  (TypeConversions a) == (TypeConversions b) = js_eq a b
+
+instance PToJSVal TypeConversions where
+  pToJSVal = unTypeConversions
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal TypeConversions where
+  pFromJSVal = TypeConversions
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal TypeConversions where
+  toJSVal = return . unTypeConversions
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal TypeConversions where
+  fromJSVal = return . fmap TypeConversions . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject TypeConversions where
+  typeGType _ = gTypeTypeConversions
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"TypeConversions\"]" gTypeTypeConversions :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.UIEvent".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.Event"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/UIEvent Mozilla UIEvent documentation>
+newtype UIEvent = UIEvent { unUIEvent :: JSVal }
+
+instance Eq (UIEvent) where
+  (UIEvent a) == (UIEvent b) = js_eq a b
+
+instance PToJSVal UIEvent where
+  pToJSVal = unUIEvent
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal UIEvent where
+  pFromJSVal = UIEvent
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal UIEvent where
+  toJSVal = return . unUIEvent
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal UIEvent where
+  fromJSVal = return . fmap UIEvent . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+class IsEvent o => IsUIEvent o
+toUIEvent :: IsUIEvent o => o -> UIEvent
+toUIEvent = UIEvent . coerce
+
+instance IsUIEvent UIEvent
+instance IsEvent UIEvent
+instance IsGObject UIEvent where
+  typeGType _ = gTypeUIEvent
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"UIEvent\"]" gTypeUIEvent :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.UIRequestEvent".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.UIEvent"
+--     * "GHCJS.DOM.Event"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/UIRequestEvent Mozilla UIRequestEvent documentation>
+newtype UIRequestEvent = UIRequestEvent { unUIRequestEvent :: JSVal }
+
+instance Eq (UIRequestEvent) where
+  (UIRequestEvent a) == (UIRequestEvent b) = js_eq a b
+
+instance PToJSVal UIRequestEvent where
+  pToJSVal = unUIRequestEvent
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal UIRequestEvent where
+  pFromJSVal = UIRequestEvent
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal UIRequestEvent where
+  toJSVal = return . unUIRequestEvent
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal UIRequestEvent where
+  fromJSVal = return . fmap UIRequestEvent . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsUIEvent UIRequestEvent
+instance IsEvent UIRequestEvent
+instance IsGObject UIRequestEvent where
+  typeGType _ = gTypeUIRequestEvent
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"UIRequestEvent\"]" gTypeUIRequestEvent :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.URL".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/URL Mozilla URL documentation>
+newtype URL = URL { unURL :: JSVal }
+
+instance Eq (URL) where
+  (URL a) == (URL b) = js_eq a b
+
+instance PToJSVal URL where
+  pToJSVal = unURL
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal URL where
+  pFromJSVal = URL
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal URL where
+  toJSVal = return . unURL
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal URL where
+  fromJSVal = return . fmap URL . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject URL where
+  typeGType _ = gTypeURL
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"URL\"]" gTypeURL :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.URLUtils".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/URLUtils Mozilla URLUtils documentation>
+newtype URLUtils = URLUtils { unURLUtils :: JSVal }
+
+instance Eq (URLUtils) where
+  (URLUtils a) == (URLUtils b) = js_eq a b
+
+instance PToJSVal URLUtils where
+  pToJSVal = unURLUtils
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal URLUtils where
+  pFromJSVal = URLUtils
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal URLUtils where
+  toJSVal = return . unURLUtils
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal URLUtils where
+  fromJSVal = return . fmap URLUtils . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject URLUtils where
+  typeGType _ = gTypeURLUtils
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"URLUtils\"]" gTypeURLUtils :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.UserMessageHandler".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/UserMessageHandler Mozilla UserMessageHandler documentation>
+newtype UserMessageHandler = UserMessageHandler { unUserMessageHandler :: JSVal }
+
+instance Eq (UserMessageHandler) where
+  (UserMessageHandler a) == (UserMessageHandler b) = js_eq a b
+
+instance PToJSVal UserMessageHandler where
+  pToJSVal = unUserMessageHandler
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal UserMessageHandler where
+  pFromJSVal = UserMessageHandler
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal UserMessageHandler where
+  toJSVal = return . unUserMessageHandler
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal UserMessageHandler where
+  fromJSVal = return . fmap UserMessageHandler . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject UserMessageHandler where
+  typeGType _ = gTypeUserMessageHandler
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"UserMessageHandler\"]" gTypeUserMessageHandler :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.UserMessageHandlersNamespace".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/UserMessageHandlersNamespace Mozilla UserMessageHandlersNamespace documentation>
+newtype UserMessageHandlersNamespace = UserMessageHandlersNamespace { unUserMessageHandlersNamespace :: JSVal }
+
+instance Eq (UserMessageHandlersNamespace) where
+  (UserMessageHandlersNamespace a) == (UserMessageHandlersNamespace b) = js_eq a b
+
+instance PToJSVal UserMessageHandlersNamespace where
+  pToJSVal = unUserMessageHandlersNamespace
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal UserMessageHandlersNamespace where
+  pFromJSVal = UserMessageHandlersNamespace
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal UserMessageHandlersNamespace where
+  toJSVal = return . unUserMessageHandlersNamespace
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal UserMessageHandlersNamespace where
+  fromJSVal = return . fmap UserMessageHandlersNamespace . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject UserMessageHandlersNamespace where
+  typeGType _ = gTypeUserMessageHandlersNamespace
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"UserMessageHandlersNamespace\"]" gTypeUserMessageHandlersNamespace :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.VTTCue".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.TextTrackCue"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/VTTCue Mozilla VTTCue documentation>
+newtype VTTCue = VTTCue { unVTTCue :: JSVal }
+
+instance Eq (VTTCue) where
+  (VTTCue a) == (VTTCue b) = js_eq a b
+
+instance PToJSVal VTTCue where
+  pToJSVal = unVTTCue
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal VTTCue where
+  pFromJSVal = VTTCue
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal VTTCue where
+  toJSVal = return . unVTTCue
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal VTTCue where
+  fromJSVal = return . fmap VTTCue . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsTextTrackCue VTTCue
+instance IsEventTarget VTTCue
+instance IsGObject VTTCue where
+  typeGType _ = gTypeVTTCue
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"VTTCue\"]" gTypeVTTCue :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.VTTRegion".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/VTTRegion Mozilla VTTRegion documentation>
+newtype VTTRegion = VTTRegion { unVTTRegion :: JSVal }
+
+instance Eq (VTTRegion) where
+  (VTTRegion a) == (VTTRegion b) = js_eq a b
+
+instance PToJSVal VTTRegion where
+  pToJSVal = unVTTRegion
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal VTTRegion where
+  pFromJSVal = VTTRegion
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal VTTRegion where
+  toJSVal = return . unVTTRegion
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal VTTRegion where
+  fromJSVal = return . fmap VTTRegion . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject VTTRegion where
+  typeGType _ = gTypeVTTRegion
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"VTTRegion\"]" gTypeVTTRegion :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.VTTRegionList".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/VTTRegionList Mozilla VTTRegionList documentation>
+newtype VTTRegionList = VTTRegionList { unVTTRegionList :: JSVal }
+
+instance Eq (VTTRegionList) where
+  (VTTRegionList a) == (VTTRegionList b) = js_eq a b
+
+instance PToJSVal VTTRegionList where
+  pToJSVal = unVTTRegionList
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal VTTRegionList where
+  pFromJSVal = VTTRegionList
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal VTTRegionList where
+  toJSVal = return . unVTTRegionList
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal VTTRegionList where
+  fromJSVal = return . fmap VTTRegionList . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject VTTRegionList where
+  typeGType _ = gTypeVTTRegionList
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"VTTRegionList\"]" gTypeVTTRegionList :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.ValidityState".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/ValidityState Mozilla ValidityState documentation>
+newtype ValidityState = ValidityState { unValidityState :: JSVal }
+
+instance Eq (ValidityState) where
+  (ValidityState a) == (ValidityState b) = js_eq a b
+
+instance PToJSVal ValidityState where
+  pToJSVal = unValidityState
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal ValidityState where
+  pFromJSVal = ValidityState
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal ValidityState where
+  toJSVal = return . unValidityState
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal ValidityState where
+  fromJSVal = return . fmap ValidityState . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject ValidityState where
+  typeGType _ = gTypeValidityState
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"ValidityState\"]" gTypeValidityState :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.VideoPlaybackQuality".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/VideoPlaybackQuality Mozilla VideoPlaybackQuality documentation>
+newtype VideoPlaybackQuality = VideoPlaybackQuality { unVideoPlaybackQuality :: JSVal }
+
+instance Eq (VideoPlaybackQuality) where
+  (VideoPlaybackQuality a) == (VideoPlaybackQuality b) = js_eq a b
+
+instance PToJSVal VideoPlaybackQuality where
+  pToJSVal = unVideoPlaybackQuality
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal VideoPlaybackQuality where
+  pFromJSVal = VideoPlaybackQuality
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal VideoPlaybackQuality where
+  toJSVal = return . unVideoPlaybackQuality
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal VideoPlaybackQuality where
+  fromJSVal = return . fmap VideoPlaybackQuality . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject VideoPlaybackQuality where
+  typeGType _ = gTypeVideoPlaybackQuality
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"VideoPlaybackQuality\"]" gTypeVideoPlaybackQuality :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.VideoStreamTrack".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.MediaStreamTrack"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/VideoStreamTrack Mozilla VideoStreamTrack documentation>
+newtype VideoStreamTrack = VideoStreamTrack { unVideoStreamTrack :: JSVal }
+
+instance Eq (VideoStreamTrack) where
+  (VideoStreamTrack a) == (VideoStreamTrack b) = js_eq a b
+
+instance PToJSVal VideoStreamTrack where
+  pToJSVal = unVideoStreamTrack
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal VideoStreamTrack where
+  pFromJSVal = VideoStreamTrack
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal VideoStreamTrack where
+  toJSVal = return . unVideoStreamTrack
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal VideoStreamTrack where
+  fromJSVal = return . fmap VideoStreamTrack . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsMediaStreamTrack VideoStreamTrack
+instance IsEventTarget VideoStreamTrack
+instance IsGObject VideoStreamTrack where
+  typeGType _ = gTypeVideoStreamTrack
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"VideoStreamTrack\"]" gTypeVideoStreamTrack :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.VideoTrack".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/VideoTrack Mozilla VideoTrack documentation>
+newtype VideoTrack = VideoTrack { unVideoTrack :: JSVal }
+
+instance Eq (VideoTrack) where
+  (VideoTrack a) == (VideoTrack b) = js_eq a b
+
+instance PToJSVal VideoTrack where
+  pToJSVal = unVideoTrack
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal VideoTrack where
+  pFromJSVal = VideoTrack
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal VideoTrack where
+  toJSVal = return . unVideoTrack
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal VideoTrack where
+  fromJSVal = return . fmap VideoTrack . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject VideoTrack where
+  typeGType _ = gTypeVideoTrack
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"VideoTrack\"]" gTypeVideoTrack :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.VideoTrackList".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/VideoTrackList Mozilla VideoTrackList documentation>
+newtype VideoTrackList = VideoTrackList { unVideoTrackList :: JSVal }
+
+instance Eq (VideoTrackList) where
+  (VideoTrackList a) == (VideoTrackList b) = js_eq a b
+
+instance PToJSVal VideoTrackList where
+  pToJSVal = unVideoTrackList
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal VideoTrackList where
+  pFromJSVal = VideoTrackList
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal VideoTrackList where
+  toJSVal = return . unVideoTrackList
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal VideoTrackList where
+  fromJSVal = return . fmap VideoTrackList . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsEventTarget VideoTrackList
+instance IsGObject VideoTrackList where
+  typeGType _ = gTypeVideoTrackList
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"VideoTrackList\"]" gTypeVideoTrackList :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.WaveShaperNode".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.AudioNode"
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/WaveShaperNode Mozilla WaveShaperNode documentation>
+newtype WaveShaperNode = WaveShaperNode { unWaveShaperNode :: JSVal }
+
+instance Eq (WaveShaperNode) where
+  (WaveShaperNode a) == (WaveShaperNode b) = js_eq a b
+
+instance PToJSVal WaveShaperNode where
+  pToJSVal = unWaveShaperNode
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal WaveShaperNode where
+  pFromJSVal = WaveShaperNode
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal WaveShaperNode where
+  toJSVal = return . unWaveShaperNode
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal WaveShaperNode where
+  fromJSVal = return . fmap WaveShaperNode . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsAudioNode WaveShaperNode
+instance IsEventTarget WaveShaperNode
+instance IsGObject WaveShaperNode where
+  typeGType _ = gTypeWaveShaperNode
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"WaveShaperNode\"]" gTypeWaveShaperNode :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.WebGL2RenderingContext".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.WebGLRenderingContextBase"
+--     * "GHCJS.DOM.CanvasRenderingContext"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/WebGL2RenderingContext Mozilla WebGL2RenderingContext documentation>
+newtype WebGL2RenderingContext = WebGL2RenderingContext { unWebGL2RenderingContext :: JSVal }
+
+instance Eq (WebGL2RenderingContext) where
+  (WebGL2RenderingContext a) == (WebGL2RenderingContext b) = js_eq a b
+
+instance PToJSVal WebGL2RenderingContext where
+  pToJSVal = unWebGL2RenderingContext
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal WebGL2RenderingContext where
+  pFromJSVal = WebGL2RenderingContext
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal WebGL2RenderingContext where
+  toJSVal = return . unWebGL2RenderingContext
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal WebGL2RenderingContext where
+  fromJSVal = return . fmap WebGL2RenderingContext . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsWebGLRenderingContextBase WebGL2RenderingContext
+instance IsCanvasRenderingContext WebGL2RenderingContext
+instance IsGObject WebGL2RenderingContext where
+  typeGType _ = gTypeWebGL2RenderingContext
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"WebGL2RenderingContext\"]" gTypeWebGL2RenderingContext :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.WebGLActiveInfo".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/WebGLActiveInfo Mozilla WebGLActiveInfo documentation>
+newtype WebGLActiveInfo = WebGLActiveInfo { unWebGLActiveInfo :: JSVal }
+
+instance Eq (WebGLActiveInfo) where
+  (WebGLActiveInfo a) == (WebGLActiveInfo b) = js_eq a b
+
+instance PToJSVal WebGLActiveInfo where
+  pToJSVal = unWebGLActiveInfo
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal WebGLActiveInfo where
+  pFromJSVal = WebGLActiveInfo
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal WebGLActiveInfo where
+  toJSVal = return . unWebGLActiveInfo
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal WebGLActiveInfo where
+  fromJSVal = return . fmap WebGLActiveInfo . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject WebGLActiveInfo where
+  typeGType _ = gTypeWebGLActiveInfo
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"WebGLActiveInfo\"]" gTypeWebGLActiveInfo :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.WebGLBuffer".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/WebGLBuffer Mozilla WebGLBuffer documentation>
+newtype WebGLBuffer = WebGLBuffer { unWebGLBuffer :: JSVal }
+
+instance Eq (WebGLBuffer) where
+  (WebGLBuffer a) == (WebGLBuffer b) = js_eq a b
+
+instance PToJSVal WebGLBuffer where
+  pToJSVal = unWebGLBuffer
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal WebGLBuffer where
+  pFromJSVal = WebGLBuffer
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal WebGLBuffer where
+  toJSVal = return . unWebGLBuffer
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal WebGLBuffer where
+  fromJSVal = return . fmap WebGLBuffer . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject WebGLBuffer where
+  typeGType _ = gTypeWebGLBuffer
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"WebGLBuffer\"]" gTypeWebGLBuffer :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.WebGLCompressedTextureATC".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/WebGLCompressedTextureATC Mozilla WebGLCompressedTextureATC documentation>
+newtype WebGLCompressedTextureATC = WebGLCompressedTextureATC { unWebGLCompressedTextureATC :: JSVal }
+
+instance Eq (WebGLCompressedTextureATC) where
+  (WebGLCompressedTextureATC a) == (WebGLCompressedTextureATC b) = js_eq a b
+
+instance PToJSVal WebGLCompressedTextureATC where
+  pToJSVal = unWebGLCompressedTextureATC
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal WebGLCompressedTextureATC where
+  pFromJSVal = WebGLCompressedTextureATC
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal WebGLCompressedTextureATC where
+  toJSVal = return . unWebGLCompressedTextureATC
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal WebGLCompressedTextureATC where
+  fromJSVal = return . fmap WebGLCompressedTextureATC . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject WebGLCompressedTextureATC where
+  typeGType _ = gTypeWebGLCompressedTextureATC
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"WebGLCompressedTextureATC\"]" gTypeWebGLCompressedTextureATC :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.WebGLCompressedTexturePVRTC".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/WebGLCompressedTexturePVRTC Mozilla WebGLCompressedTexturePVRTC documentation>
+newtype WebGLCompressedTexturePVRTC = WebGLCompressedTexturePVRTC { unWebGLCompressedTexturePVRTC :: JSVal }
+
+instance Eq (WebGLCompressedTexturePVRTC) where
+  (WebGLCompressedTexturePVRTC a) == (WebGLCompressedTexturePVRTC b) = js_eq a b
+
+instance PToJSVal WebGLCompressedTexturePVRTC where
+  pToJSVal = unWebGLCompressedTexturePVRTC
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal WebGLCompressedTexturePVRTC where
+  pFromJSVal = WebGLCompressedTexturePVRTC
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal WebGLCompressedTexturePVRTC where
+  toJSVal = return . unWebGLCompressedTexturePVRTC
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal WebGLCompressedTexturePVRTC where
+  fromJSVal = return . fmap WebGLCompressedTexturePVRTC . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject WebGLCompressedTexturePVRTC where
+  typeGType _ = gTypeWebGLCompressedTexturePVRTC
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"WebGLCompressedTexturePVRTC\"]" gTypeWebGLCompressedTexturePVRTC :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.WebGLCompressedTextureS3TC".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/WebGLCompressedTextureS3TC Mozilla WebGLCompressedTextureS3TC documentation>
+newtype WebGLCompressedTextureS3TC = WebGLCompressedTextureS3TC { unWebGLCompressedTextureS3TC :: JSVal }
+
+instance Eq (WebGLCompressedTextureS3TC) where
+  (WebGLCompressedTextureS3TC a) == (WebGLCompressedTextureS3TC b) = js_eq a b
+
+instance PToJSVal WebGLCompressedTextureS3TC where
+  pToJSVal = unWebGLCompressedTextureS3TC
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal WebGLCompressedTextureS3TC where
+  pFromJSVal = WebGLCompressedTextureS3TC
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal WebGLCompressedTextureS3TC where
+  toJSVal = return . unWebGLCompressedTextureS3TC
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal WebGLCompressedTextureS3TC where
+  fromJSVal = return . fmap WebGLCompressedTextureS3TC . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject WebGLCompressedTextureS3TC where
+  typeGType _ = gTypeWebGLCompressedTextureS3TC
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"WebGLCompressedTextureS3TC\"]" gTypeWebGLCompressedTextureS3TC :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.WebGLContextAttributes".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/WebGLContextAttributes Mozilla WebGLContextAttributes documentation>
+newtype WebGLContextAttributes = WebGLContextAttributes { unWebGLContextAttributes :: JSVal }
+
+instance Eq (WebGLContextAttributes) where
+  (WebGLContextAttributes a) == (WebGLContextAttributes b) = js_eq a b
+
+instance PToJSVal WebGLContextAttributes where
+  pToJSVal = unWebGLContextAttributes
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal WebGLContextAttributes where
+  pFromJSVal = WebGLContextAttributes
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal WebGLContextAttributes where
+  toJSVal = return . unWebGLContextAttributes
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal WebGLContextAttributes where
+  fromJSVal = return . fmap WebGLContextAttributes . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject WebGLContextAttributes where
+  typeGType _ = gTypeWebGLContextAttributes
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"WebGLContextAttributes\"]" gTypeWebGLContextAttributes :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.WebGLContextEvent".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.Event"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/WebGLContextEvent Mozilla WebGLContextEvent documentation>
+newtype WebGLContextEvent = WebGLContextEvent { unWebGLContextEvent :: JSVal }
+
+instance Eq (WebGLContextEvent) where
+  (WebGLContextEvent a) == (WebGLContextEvent b) = js_eq a b
+
+instance PToJSVal WebGLContextEvent where
+  pToJSVal = unWebGLContextEvent
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal WebGLContextEvent where
+  pFromJSVal = WebGLContextEvent
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal WebGLContextEvent where
+  toJSVal = return . unWebGLContextEvent
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal WebGLContextEvent where
+  fromJSVal = return . fmap WebGLContextEvent . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsEvent WebGLContextEvent
+instance IsGObject WebGLContextEvent where
+  typeGType _ = gTypeWebGLContextEvent
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"WebGLContextEvent\"]" gTypeWebGLContextEvent :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.WebGLDebugRendererInfo".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/WebGLDebugRendererInfo Mozilla WebGLDebugRendererInfo documentation>
+newtype WebGLDebugRendererInfo = WebGLDebugRendererInfo { unWebGLDebugRendererInfo :: JSVal }
+
+instance Eq (WebGLDebugRendererInfo) where
+  (WebGLDebugRendererInfo a) == (WebGLDebugRendererInfo b) = js_eq a b
+
+instance PToJSVal WebGLDebugRendererInfo where
+  pToJSVal = unWebGLDebugRendererInfo
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal WebGLDebugRendererInfo where
+  pFromJSVal = WebGLDebugRendererInfo
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal WebGLDebugRendererInfo where
+  toJSVal = return . unWebGLDebugRendererInfo
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal WebGLDebugRendererInfo where
+  fromJSVal = return . fmap WebGLDebugRendererInfo . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject WebGLDebugRendererInfo where
+  typeGType _ = gTypeWebGLDebugRendererInfo
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"WebGLDebugRendererInfo\"]" gTypeWebGLDebugRendererInfo :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.WebGLDebugShaders".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/WebGLDebugShaders Mozilla WebGLDebugShaders documentation>
+newtype WebGLDebugShaders = WebGLDebugShaders { unWebGLDebugShaders :: JSVal }
+
+instance Eq (WebGLDebugShaders) where
+  (WebGLDebugShaders a) == (WebGLDebugShaders b) = js_eq a b
+
+instance PToJSVal WebGLDebugShaders where
+  pToJSVal = unWebGLDebugShaders
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal WebGLDebugShaders where
+  pFromJSVal = WebGLDebugShaders
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal WebGLDebugShaders where
+  toJSVal = return . unWebGLDebugShaders
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal WebGLDebugShaders where
+  fromJSVal = return . fmap WebGLDebugShaders . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject WebGLDebugShaders where
+  typeGType _ = gTypeWebGLDebugShaders
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"WebGLDebugShaders\"]" gTypeWebGLDebugShaders :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.WebGLDepthTexture".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/WebGLDepthTexture Mozilla WebGLDepthTexture documentation>
+newtype WebGLDepthTexture = WebGLDepthTexture { unWebGLDepthTexture :: JSVal }
+
+instance Eq (WebGLDepthTexture) where
+  (WebGLDepthTexture a) == (WebGLDepthTexture b) = js_eq a b
+
+instance PToJSVal WebGLDepthTexture where
+  pToJSVal = unWebGLDepthTexture
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal WebGLDepthTexture where
+  pFromJSVal = WebGLDepthTexture
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal WebGLDepthTexture where
+  toJSVal = return . unWebGLDepthTexture
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal WebGLDepthTexture where
+  fromJSVal = return . fmap WebGLDepthTexture . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject WebGLDepthTexture where
+  typeGType _ = gTypeWebGLDepthTexture
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"WebGLDepthTexture\"]" gTypeWebGLDepthTexture :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.WebGLDrawBuffers".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/WebGLDrawBuffers Mozilla WebGLDrawBuffers documentation>
+newtype WebGLDrawBuffers = WebGLDrawBuffers { unWebGLDrawBuffers :: JSVal }
+
+instance Eq (WebGLDrawBuffers) where
+  (WebGLDrawBuffers a) == (WebGLDrawBuffers b) = js_eq a b
+
+instance PToJSVal WebGLDrawBuffers where
+  pToJSVal = unWebGLDrawBuffers
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal WebGLDrawBuffers where
+  pFromJSVal = WebGLDrawBuffers
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal WebGLDrawBuffers where
+  toJSVal = return . unWebGLDrawBuffers
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal WebGLDrawBuffers where
+  fromJSVal = return . fmap WebGLDrawBuffers . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject WebGLDrawBuffers where
+  typeGType _ = gTypeWebGLDrawBuffers
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"WebGLDrawBuffers\"]" gTypeWebGLDrawBuffers :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.WebGLFramebuffer".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/WebGLFramebuffer Mozilla WebGLFramebuffer documentation>
+newtype WebGLFramebuffer = WebGLFramebuffer { unWebGLFramebuffer :: JSVal }
+
+instance Eq (WebGLFramebuffer) where
+  (WebGLFramebuffer a) == (WebGLFramebuffer b) = js_eq a b
+
+instance PToJSVal WebGLFramebuffer where
+  pToJSVal = unWebGLFramebuffer
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal WebGLFramebuffer where
+  pFromJSVal = WebGLFramebuffer
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal WebGLFramebuffer where
+  toJSVal = return . unWebGLFramebuffer
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal WebGLFramebuffer where
+  fromJSVal = return . fmap WebGLFramebuffer . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject WebGLFramebuffer where
+  typeGType _ = gTypeWebGLFramebuffer
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"WebGLFramebuffer\"]" gTypeWebGLFramebuffer :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.WebGLLoseContext".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/WebGLLoseContext Mozilla WebGLLoseContext documentation>
+newtype WebGLLoseContext = WebGLLoseContext { unWebGLLoseContext :: JSVal }
+
+instance Eq (WebGLLoseContext) where
+  (WebGLLoseContext a) == (WebGLLoseContext b) = js_eq a b
+
+instance PToJSVal WebGLLoseContext where
+  pToJSVal = unWebGLLoseContext
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal WebGLLoseContext where
+  pFromJSVal = WebGLLoseContext
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal WebGLLoseContext where
+  toJSVal = return . unWebGLLoseContext
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal WebGLLoseContext where
+  fromJSVal = return . fmap WebGLLoseContext . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject WebGLLoseContext where
+  typeGType _ = gTypeWebGLLoseContext
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"WebGLLoseContext\"]" gTypeWebGLLoseContext :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.WebGLProgram".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/WebGLProgram Mozilla WebGLProgram documentation>
+newtype WebGLProgram = WebGLProgram { unWebGLProgram :: JSVal }
+
+instance Eq (WebGLProgram) where
+  (WebGLProgram a) == (WebGLProgram b) = js_eq a b
+
+instance PToJSVal WebGLProgram where
+  pToJSVal = unWebGLProgram
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal WebGLProgram where
+  pFromJSVal = WebGLProgram
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal WebGLProgram where
+  toJSVal = return . unWebGLProgram
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal WebGLProgram where
+  fromJSVal = return . fmap WebGLProgram . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject WebGLProgram where
+  typeGType _ = gTypeWebGLProgram
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"WebGLProgram\"]" gTypeWebGLProgram :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.WebGLQuery".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/WebGLQuery Mozilla WebGLQuery documentation>
+newtype WebGLQuery = WebGLQuery { unWebGLQuery :: JSVal }
+
+instance Eq (WebGLQuery) where
+  (WebGLQuery a) == (WebGLQuery b) = js_eq a b
+
+instance PToJSVal WebGLQuery where
+  pToJSVal = unWebGLQuery
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal WebGLQuery where
+  pFromJSVal = WebGLQuery
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal WebGLQuery where
+  toJSVal = return . unWebGLQuery
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal WebGLQuery where
+  fromJSVal = return . fmap WebGLQuery . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject WebGLQuery where
+  typeGType _ = gTypeWebGLQuery
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"WebGLQuery\"]" gTypeWebGLQuery :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.WebGLRenderbuffer".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/WebGLRenderbuffer Mozilla WebGLRenderbuffer documentation>
+newtype WebGLRenderbuffer = WebGLRenderbuffer { unWebGLRenderbuffer :: JSVal }
+
+instance Eq (WebGLRenderbuffer) where
+  (WebGLRenderbuffer a) == (WebGLRenderbuffer b) = js_eq a b
+
+instance PToJSVal WebGLRenderbuffer where
+  pToJSVal = unWebGLRenderbuffer
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal WebGLRenderbuffer where
+  pFromJSVal = WebGLRenderbuffer
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal WebGLRenderbuffer where
+  toJSVal = return . unWebGLRenderbuffer
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal WebGLRenderbuffer where
+  fromJSVal = return . fmap WebGLRenderbuffer . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject WebGLRenderbuffer where
+  typeGType _ = gTypeWebGLRenderbuffer
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"WebGLRenderbuffer\"]" gTypeWebGLRenderbuffer :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.WebGLRenderingContext".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.WebGLRenderingContextBase"
+--     * "GHCJS.DOM.CanvasRenderingContext"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/WebGLRenderingContext Mozilla WebGLRenderingContext documentation>
+newtype WebGLRenderingContext = WebGLRenderingContext { unWebGLRenderingContext :: JSVal }
+
+instance Eq (WebGLRenderingContext) where
+  (WebGLRenderingContext a) == (WebGLRenderingContext b) = js_eq a b
+
+instance PToJSVal WebGLRenderingContext where
+  pToJSVal = unWebGLRenderingContext
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal WebGLRenderingContext where
+  pFromJSVal = WebGLRenderingContext
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal WebGLRenderingContext where
+  toJSVal = return . unWebGLRenderingContext
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal WebGLRenderingContext where
+  fromJSVal = return . fmap WebGLRenderingContext . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsWebGLRenderingContextBase WebGLRenderingContext
+instance IsCanvasRenderingContext WebGLRenderingContext
+instance IsGObject WebGLRenderingContext where
+  typeGType _ = gTypeWebGLRenderingContext
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"WebGLRenderingContext\"]" gTypeWebGLRenderingContext :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.WebGLRenderingContextBase".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.CanvasRenderingContext"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/WebGLRenderingContextBase Mozilla WebGLRenderingContextBase documentation>
+newtype WebGLRenderingContextBase = WebGLRenderingContextBase { unWebGLRenderingContextBase :: JSVal }
+
+instance Eq (WebGLRenderingContextBase) where
+  (WebGLRenderingContextBase a) == (WebGLRenderingContextBase b) = js_eq a b
+
+instance PToJSVal WebGLRenderingContextBase where
+  pToJSVal = unWebGLRenderingContextBase
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal WebGLRenderingContextBase where
+  pFromJSVal = WebGLRenderingContextBase
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal WebGLRenderingContextBase where
+  toJSVal = return . unWebGLRenderingContextBase
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal WebGLRenderingContextBase where
+  fromJSVal = return . fmap WebGLRenderingContextBase . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+class IsCanvasRenderingContext o => IsWebGLRenderingContextBase o
+toWebGLRenderingContextBase :: IsWebGLRenderingContextBase o => o -> WebGLRenderingContextBase
+toWebGLRenderingContextBase = WebGLRenderingContextBase . coerce
+
+instance IsWebGLRenderingContextBase WebGLRenderingContextBase
+instance IsCanvasRenderingContext WebGLRenderingContextBase
+instance IsGObject WebGLRenderingContextBase where
+  typeGType _ = gTypeWebGLRenderingContextBase
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"WebGLRenderingContextBase\"]" gTypeWebGLRenderingContextBase :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.WebGLSampler".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/WebGLSampler Mozilla WebGLSampler documentation>
+newtype WebGLSampler = WebGLSampler { unWebGLSampler :: JSVal }
+
+instance Eq (WebGLSampler) where
+  (WebGLSampler a) == (WebGLSampler b) = js_eq a b
+
+instance PToJSVal WebGLSampler where
+  pToJSVal = unWebGLSampler
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal WebGLSampler where
+  pFromJSVal = WebGLSampler
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal WebGLSampler where
+  toJSVal = return . unWebGLSampler
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal WebGLSampler where
+  fromJSVal = return . fmap WebGLSampler . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject WebGLSampler where
+  typeGType _ = gTypeWebGLSampler
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"WebGLSampler\"]" gTypeWebGLSampler :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.WebGLShader".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/WebGLShader Mozilla WebGLShader documentation>
+newtype WebGLShader = WebGLShader { unWebGLShader :: JSVal }
+
+instance Eq (WebGLShader) where
+  (WebGLShader a) == (WebGLShader b) = js_eq a b
+
+instance PToJSVal WebGLShader where
+  pToJSVal = unWebGLShader
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal WebGLShader where
+  pFromJSVal = WebGLShader
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal WebGLShader where
+  toJSVal = return . unWebGLShader
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal WebGLShader where
+  fromJSVal = return . fmap WebGLShader . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject WebGLShader where
+  typeGType _ = gTypeWebGLShader
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"WebGLShader\"]" gTypeWebGLShader :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.WebGLShaderPrecisionFormat".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/WebGLShaderPrecisionFormat Mozilla WebGLShaderPrecisionFormat documentation>
+newtype WebGLShaderPrecisionFormat = WebGLShaderPrecisionFormat { unWebGLShaderPrecisionFormat :: JSVal }
+
+instance Eq (WebGLShaderPrecisionFormat) where
+  (WebGLShaderPrecisionFormat a) == (WebGLShaderPrecisionFormat b) = js_eq a b
+
+instance PToJSVal WebGLShaderPrecisionFormat where
+  pToJSVal = unWebGLShaderPrecisionFormat
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal WebGLShaderPrecisionFormat where
+  pFromJSVal = WebGLShaderPrecisionFormat
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal WebGLShaderPrecisionFormat where
+  toJSVal = return . unWebGLShaderPrecisionFormat
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal WebGLShaderPrecisionFormat where
+  fromJSVal = return . fmap WebGLShaderPrecisionFormat . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject WebGLShaderPrecisionFormat where
+  typeGType _ = gTypeWebGLShaderPrecisionFormat
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"WebGLShaderPrecisionFormat\"]" gTypeWebGLShaderPrecisionFormat :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.WebGLSync".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/WebGLSync Mozilla WebGLSync documentation>
+newtype WebGLSync = WebGLSync { unWebGLSync :: JSVal }
+
+instance Eq (WebGLSync) where
+  (WebGLSync a) == (WebGLSync b) = js_eq a b
+
+instance PToJSVal WebGLSync where
+  pToJSVal = unWebGLSync
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal WebGLSync where
+  pFromJSVal = WebGLSync
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal WebGLSync where
+  toJSVal = return . unWebGLSync
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal WebGLSync where
+  fromJSVal = return . fmap WebGLSync . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject WebGLSync where
+  typeGType _ = gTypeWebGLSync
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"WebGLSync\"]" gTypeWebGLSync :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.WebGLTexture".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/WebGLTexture Mozilla WebGLTexture documentation>
+newtype WebGLTexture = WebGLTexture { unWebGLTexture :: JSVal }
+
+instance Eq (WebGLTexture) where
+  (WebGLTexture a) == (WebGLTexture b) = js_eq a b
+
+instance PToJSVal WebGLTexture where
+  pToJSVal = unWebGLTexture
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal WebGLTexture where
+  pFromJSVal = WebGLTexture
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal WebGLTexture where
+  toJSVal = return . unWebGLTexture
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal WebGLTexture where
+  fromJSVal = return . fmap WebGLTexture . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject WebGLTexture where
+  typeGType _ = gTypeWebGLTexture
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"WebGLTexture\"]" gTypeWebGLTexture :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.WebGLTransformFeedback".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/WebGLTransformFeedback Mozilla WebGLTransformFeedback documentation>
+newtype WebGLTransformFeedback = WebGLTransformFeedback { unWebGLTransformFeedback :: JSVal }
+
+instance Eq (WebGLTransformFeedback) where
+  (WebGLTransformFeedback a) == (WebGLTransformFeedback b) = js_eq a b
+
+instance PToJSVal WebGLTransformFeedback where
+  pToJSVal = unWebGLTransformFeedback
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal WebGLTransformFeedback where
+  pFromJSVal = WebGLTransformFeedback
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal WebGLTransformFeedback where
+  toJSVal = return . unWebGLTransformFeedback
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal WebGLTransformFeedback where
+  fromJSVal = return . fmap WebGLTransformFeedback . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject WebGLTransformFeedback where
+  typeGType _ = gTypeWebGLTransformFeedback
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"WebGLTransformFeedback\"]" gTypeWebGLTransformFeedback :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.WebGLUniformLocation".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/WebGLUniformLocation Mozilla WebGLUniformLocation documentation>
+newtype WebGLUniformLocation = WebGLUniformLocation { unWebGLUniformLocation :: JSVal }
+
+instance Eq (WebGLUniformLocation) where
+  (WebGLUniformLocation a) == (WebGLUniformLocation b) = js_eq a b
+
+instance PToJSVal WebGLUniformLocation where
+  pToJSVal = unWebGLUniformLocation
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal WebGLUniformLocation where
+  pFromJSVal = WebGLUniformLocation
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal WebGLUniformLocation where
+  toJSVal = return . unWebGLUniformLocation
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal WebGLUniformLocation where
+  fromJSVal = return . fmap WebGLUniformLocation . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject WebGLUniformLocation where
+  typeGType _ = gTypeWebGLUniformLocation
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"WebGLUniformLocation\"]" gTypeWebGLUniformLocation :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.WebGLVertexArrayObject".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/WebGLVertexArrayObject Mozilla WebGLVertexArrayObject documentation>
+newtype WebGLVertexArrayObject = WebGLVertexArrayObject { unWebGLVertexArrayObject :: JSVal }
+
+instance Eq (WebGLVertexArrayObject) where
+  (WebGLVertexArrayObject a) == (WebGLVertexArrayObject b) = js_eq a b
+
+instance PToJSVal WebGLVertexArrayObject where
+  pToJSVal = unWebGLVertexArrayObject
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal WebGLVertexArrayObject where
+  pFromJSVal = WebGLVertexArrayObject
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal WebGLVertexArrayObject where
+  toJSVal = return . unWebGLVertexArrayObject
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal WebGLVertexArrayObject where
+  fromJSVal = return . fmap WebGLVertexArrayObject . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject WebGLVertexArrayObject where
+  typeGType _ = gTypeWebGLVertexArrayObject
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"WebGLVertexArrayObject\"]" gTypeWebGLVertexArrayObject :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.WebGLVertexArrayObjectOES".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/WebGLVertexArrayObjectOES Mozilla WebGLVertexArrayObjectOES documentation>
+newtype WebGLVertexArrayObjectOES = WebGLVertexArrayObjectOES { unWebGLVertexArrayObjectOES :: JSVal }
+
+instance Eq (WebGLVertexArrayObjectOES) where
+  (WebGLVertexArrayObjectOES a) == (WebGLVertexArrayObjectOES b) = js_eq a b
+
+instance PToJSVal WebGLVertexArrayObjectOES where
+  pToJSVal = unWebGLVertexArrayObjectOES
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal WebGLVertexArrayObjectOES where
+  pFromJSVal = WebGLVertexArrayObjectOES
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal WebGLVertexArrayObjectOES where
+  toJSVal = return . unWebGLVertexArrayObjectOES
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal WebGLVertexArrayObjectOES where
+  fromJSVal = return . fmap WebGLVertexArrayObjectOES . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject WebGLVertexArrayObjectOES where
+  typeGType _ = gTypeWebGLVertexArrayObjectOES
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"WebGLVertexArrayObjectOES\"]" gTypeWebGLVertexArrayObjectOES :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.WebKitAnimationEvent".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.Event"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/WebKitAnimationEvent Mozilla WebKitAnimationEvent documentation>
+newtype WebKitAnimationEvent = WebKitAnimationEvent { unWebKitAnimationEvent :: JSVal }
+
+instance Eq (WebKitAnimationEvent) where
+  (WebKitAnimationEvent a) == (WebKitAnimationEvent b) = js_eq a b
+
+instance PToJSVal WebKitAnimationEvent where
+  pToJSVal = unWebKitAnimationEvent
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal WebKitAnimationEvent where
+  pFromJSVal = WebKitAnimationEvent
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal WebKitAnimationEvent where
+  toJSVal = return . unWebKitAnimationEvent
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal WebKitAnimationEvent where
+  fromJSVal = return . fmap WebKitAnimationEvent . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsEvent WebKitAnimationEvent
+instance IsGObject WebKitAnimationEvent where
+  typeGType _ = gTypeWebKitAnimationEvent
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"WebKitAnimationEvent\"]" gTypeWebKitAnimationEvent :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.WebKitCSSFilterValue".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.CSSValueList"
+--     * "GHCJS.DOM.CSSValue"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/WebKitCSSFilterValue Mozilla WebKitCSSFilterValue documentation>
+newtype WebKitCSSFilterValue = WebKitCSSFilterValue { unWebKitCSSFilterValue :: JSVal }
+
+instance Eq (WebKitCSSFilterValue) where
+  (WebKitCSSFilterValue a) == (WebKitCSSFilterValue b) = js_eq a b
+
+instance PToJSVal WebKitCSSFilterValue where
+  pToJSVal = unWebKitCSSFilterValue
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal WebKitCSSFilterValue where
+  pFromJSVal = WebKitCSSFilterValue
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal WebKitCSSFilterValue where
+  toJSVal = return . unWebKitCSSFilterValue
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal WebKitCSSFilterValue where
+  fromJSVal = return . fmap WebKitCSSFilterValue . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsCSSValueList WebKitCSSFilterValue
+instance IsCSSValue WebKitCSSFilterValue
+instance IsGObject WebKitCSSFilterValue where
+  typeGType _ = gTypeWebKitCSSFilterValue
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"WebKitCSSFilterValue\"]" gTypeWebKitCSSFilterValue :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.WebKitCSSMatrix".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/WebKitCSSMatrix Mozilla WebKitCSSMatrix documentation>
+newtype WebKitCSSMatrix = WebKitCSSMatrix { unWebKitCSSMatrix :: JSVal }
+
+instance Eq (WebKitCSSMatrix) where
+  (WebKitCSSMatrix a) == (WebKitCSSMatrix b) = js_eq a b
+
+instance PToJSVal WebKitCSSMatrix where
+  pToJSVal = unWebKitCSSMatrix
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal WebKitCSSMatrix where
+  pFromJSVal = WebKitCSSMatrix
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal WebKitCSSMatrix where
+  toJSVal = return . unWebKitCSSMatrix
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal WebKitCSSMatrix where
+  fromJSVal = return . fmap WebKitCSSMatrix . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject WebKitCSSMatrix where
+  typeGType _ = gTypeWebKitCSSMatrix
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"WebKitCSSMatrix\"]" gTypeWebKitCSSMatrix :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.WebKitCSSRegionRule".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.CSSRule"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/WebKitCSSRegionRule Mozilla WebKitCSSRegionRule documentation>
+newtype WebKitCSSRegionRule = WebKitCSSRegionRule { unWebKitCSSRegionRule :: JSVal }
+
+instance Eq (WebKitCSSRegionRule) where
+  (WebKitCSSRegionRule a) == (WebKitCSSRegionRule b) = js_eq a b
+
+instance PToJSVal WebKitCSSRegionRule where
+  pToJSVal = unWebKitCSSRegionRule
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal WebKitCSSRegionRule where
+  pFromJSVal = WebKitCSSRegionRule
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal WebKitCSSRegionRule where
+  toJSVal = return . unWebKitCSSRegionRule
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal WebKitCSSRegionRule where
+  fromJSVal = return . fmap WebKitCSSRegionRule . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsCSSRule WebKitCSSRegionRule
+instance IsGObject WebKitCSSRegionRule where
+  typeGType _ = gTypeWebKitCSSRegionRule
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"WebKitCSSRegionRule\"]" gTypeWebKitCSSRegionRule :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.WebKitCSSTransformValue".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.CSSValueList"
+--     * "GHCJS.DOM.CSSValue"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/WebKitCSSTransformValue Mozilla WebKitCSSTransformValue documentation>
+newtype WebKitCSSTransformValue = WebKitCSSTransformValue { unWebKitCSSTransformValue :: JSVal }
+
+instance Eq (WebKitCSSTransformValue) where
+  (WebKitCSSTransformValue a) == (WebKitCSSTransformValue b) = js_eq a b
+
+instance PToJSVal WebKitCSSTransformValue where
+  pToJSVal = unWebKitCSSTransformValue
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal WebKitCSSTransformValue where
+  pFromJSVal = WebKitCSSTransformValue
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal WebKitCSSTransformValue where
+  toJSVal = return . unWebKitCSSTransformValue
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal WebKitCSSTransformValue where
+  fromJSVal = return . fmap WebKitCSSTransformValue . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsCSSValueList WebKitCSSTransformValue
+instance IsCSSValue WebKitCSSTransformValue
+instance IsGObject WebKitCSSTransformValue where
+  typeGType _ = gTypeWebKitCSSTransformValue
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"WebKitCSSTransformValue\"]" gTypeWebKitCSSTransformValue :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.WebKitCSSViewportRule".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.CSSRule"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/WebKitCSSViewportRule Mozilla WebKitCSSViewportRule documentation>
+newtype WebKitCSSViewportRule = WebKitCSSViewportRule { unWebKitCSSViewportRule :: JSVal }
+
+instance Eq (WebKitCSSViewportRule) where
+  (WebKitCSSViewportRule a) == (WebKitCSSViewportRule b) = js_eq a b
+
+instance PToJSVal WebKitCSSViewportRule where
+  pToJSVal = unWebKitCSSViewportRule
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal WebKitCSSViewportRule where
+  pFromJSVal = WebKitCSSViewportRule
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal WebKitCSSViewportRule where
+  toJSVal = return . unWebKitCSSViewportRule
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal WebKitCSSViewportRule where
+  fromJSVal = return . fmap WebKitCSSViewportRule . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsCSSRule WebKitCSSViewportRule
+instance IsGObject WebKitCSSViewportRule where
+  typeGType _ = gTypeWebKitCSSViewportRule
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"WebKitCSSViewportRule\"]" gTypeWebKitCSSViewportRule :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.WebKitNamedFlow".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/WebKitNamedFlow Mozilla WebKitNamedFlow documentation>
+newtype WebKitNamedFlow = WebKitNamedFlow { unWebKitNamedFlow :: JSVal }
+
+instance Eq (WebKitNamedFlow) where
+  (WebKitNamedFlow a) == (WebKitNamedFlow b) = js_eq a b
+
+instance PToJSVal WebKitNamedFlow where
+  pToJSVal = unWebKitNamedFlow
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal WebKitNamedFlow where
+  pFromJSVal = WebKitNamedFlow
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal WebKitNamedFlow where
+  toJSVal = return . unWebKitNamedFlow
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal WebKitNamedFlow where
+  fromJSVal = return . fmap WebKitNamedFlow . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsEventTarget WebKitNamedFlow
+instance IsGObject WebKitNamedFlow where
+  typeGType _ = gTypeWebKitNamedFlow
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"WebKitNamedFlow\"]" gTypeWebKitNamedFlow :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.WebKitNamespace".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/WebKitNamespace Mozilla WebKitNamespace documentation>
+newtype WebKitNamespace = WebKitNamespace { unWebKitNamespace :: JSVal }
+
+instance Eq (WebKitNamespace) where
+  (WebKitNamespace a) == (WebKitNamespace b) = js_eq a b
+
+instance PToJSVal WebKitNamespace where
+  pToJSVal = unWebKitNamespace
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal WebKitNamespace where
+  pFromJSVal = WebKitNamespace
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal WebKitNamespace where
+  toJSVal = return . unWebKitNamespace
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal WebKitNamespace where
+  fromJSVal = return . fmap WebKitNamespace . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject WebKitNamespace where
+  typeGType _ = gTypeWebKitNamespace
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"WebKitNamespace\"]" gTypeWebKitNamespace :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.WebKitPlaybackTargetAvailabilityEvent".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.Event"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/WebKitPlaybackTargetAvailabilityEvent Mozilla WebKitPlaybackTargetAvailabilityEvent documentation>
+newtype WebKitPlaybackTargetAvailabilityEvent = WebKitPlaybackTargetAvailabilityEvent { unWebKitPlaybackTargetAvailabilityEvent :: JSVal }
+
+instance Eq (WebKitPlaybackTargetAvailabilityEvent) where
+  (WebKitPlaybackTargetAvailabilityEvent a) == (WebKitPlaybackTargetAvailabilityEvent b) = js_eq a b
+
+instance PToJSVal WebKitPlaybackTargetAvailabilityEvent where
+  pToJSVal = unWebKitPlaybackTargetAvailabilityEvent
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal WebKitPlaybackTargetAvailabilityEvent where
+  pFromJSVal = WebKitPlaybackTargetAvailabilityEvent
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal WebKitPlaybackTargetAvailabilityEvent where
+  toJSVal = return . unWebKitPlaybackTargetAvailabilityEvent
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal WebKitPlaybackTargetAvailabilityEvent where
+  fromJSVal = return . fmap WebKitPlaybackTargetAvailabilityEvent . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsEvent WebKitPlaybackTargetAvailabilityEvent
+instance IsGObject WebKitPlaybackTargetAvailabilityEvent where
+  typeGType _ = gTypeWebKitPlaybackTargetAvailabilityEvent
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"WebKitPlaybackTargetAvailabilityEvent\"]" gTypeWebKitPlaybackTargetAvailabilityEvent :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.WebKitPoint".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/WebKitPoint Mozilla WebKitPoint documentation>
+newtype WebKitPoint = WebKitPoint { unWebKitPoint :: JSVal }
+
+instance Eq (WebKitPoint) where
+  (WebKitPoint a) == (WebKitPoint b) = js_eq a b
+
+instance PToJSVal WebKitPoint where
+  pToJSVal = unWebKitPoint
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal WebKitPoint where
+  pFromJSVal = WebKitPoint
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal WebKitPoint where
+  toJSVal = return . unWebKitPoint
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal WebKitPoint where
+  fromJSVal = return . fmap WebKitPoint . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject WebKitPoint where
+  typeGType _ = gTypeWebKitPoint
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"WebKitPoint\"]" gTypeWebKitPoint :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.WebKitTransitionEvent".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.Event"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/WebKitTransitionEvent Mozilla WebKitTransitionEvent documentation>
+newtype WebKitTransitionEvent = WebKitTransitionEvent { unWebKitTransitionEvent :: JSVal }
+
+instance Eq (WebKitTransitionEvent) where
+  (WebKitTransitionEvent a) == (WebKitTransitionEvent b) = js_eq a b
+
+instance PToJSVal WebKitTransitionEvent where
+  pToJSVal = unWebKitTransitionEvent
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal WebKitTransitionEvent where
+  pFromJSVal = WebKitTransitionEvent
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal WebKitTransitionEvent where
+  toJSVal = return . unWebKitTransitionEvent
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal WebKitTransitionEvent where
+  fromJSVal = return . fmap WebKitTransitionEvent . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsEvent WebKitTransitionEvent
+instance IsGObject WebKitTransitionEvent where
+  typeGType _ = gTypeWebKitTransitionEvent
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"WebKitTransitionEvent\"]" gTypeWebKitTransitionEvent :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.WebSocket".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/WebSocket Mozilla WebSocket documentation>
+newtype WebSocket = WebSocket { unWebSocket :: JSVal }
+
+instance Eq (WebSocket) where
+  (WebSocket a) == (WebSocket b) = js_eq a b
+
+instance PToJSVal WebSocket where
+  pToJSVal = unWebSocket
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal WebSocket where
+  pFromJSVal = WebSocket
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal WebSocket where
+  toJSVal = return . unWebSocket
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal WebSocket where
+  fromJSVal = return . fmap WebSocket . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsEventTarget WebSocket
+instance IsGObject WebSocket where
+  typeGType _ = gTypeWebSocket
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"WebSocket\"]" gTypeWebSocket :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.WheelEvent".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.MouseEvent"
+--     * "GHCJS.DOM.UIEvent"
+--     * "GHCJS.DOM.Event"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/WheelEvent Mozilla WheelEvent documentation>
+newtype WheelEvent = WheelEvent { unWheelEvent :: JSVal }
+
+instance Eq (WheelEvent) where
+  (WheelEvent a) == (WheelEvent b) = js_eq a b
+
+instance PToJSVal WheelEvent where
+  pToJSVal = unWheelEvent
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal WheelEvent where
+  pFromJSVal = WheelEvent
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal WheelEvent where
+  toJSVal = return . unWheelEvent
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal WheelEvent where
+  fromJSVal = return . fmap WheelEvent . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsMouseEvent WheelEvent
+instance IsUIEvent WheelEvent
+instance IsEvent WheelEvent
+instance IsGObject WheelEvent where
+  typeGType _ = gTypeWheelEvent
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"WheelEvent\"]" gTypeWheelEvent :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.Window".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/Window Mozilla Window documentation>
+newtype Window = Window { unWindow :: JSVal }
+
+instance Eq (Window) where
+  (Window a) == (Window b) = js_eq a b
+
+instance PToJSVal Window where
+  pToJSVal = unWindow
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal Window where
+  pFromJSVal = Window
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal Window where
+  toJSVal = return . unWindow
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal Window where
+  fromJSVal = return . fmap Window . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsEventTarget Window
+instance IsGObject Window where
+  typeGType _ = gTypeWindow
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"Window\"]" gTypeWindow :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.WindowBase64".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/WindowBase64 Mozilla WindowBase64 documentation>
+newtype WindowBase64 = WindowBase64 { unWindowBase64 :: JSVal }
+
+instance Eq (WindowBase64) where
+  (WindowBase64 a) == (WindowBase64 b) = js_eq a b
+
+instance PToJSVal WindowBase64 where
+  pToJSVal = unWindowBase64
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal WindowBase64 where
+  pFromJSVal = WindowBase64
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal WindowBase64 where
+  toJSVal = return . unWindowBase64
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal WindowBase64 where
+  fromJSVal = return . fmap WindowBase64 . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject WindowBase64 where
+  typeGType _ = gTypeWindowBase64
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"WindowBase64\"]" gTypeWindowBase64 :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.WindowTimers".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/WindowTimers Mozilla WindowTimers documentation>
+newtype WindowTimers = WindowTimers { unWindowTimers :: JSVal }
+
+instance Eq (WindowTimers) where
+  (WindowTimers a) == (WindowTimers b) = js_eq a b
+
+instance PToJSVal WindowTimers where
+  pToJSVal = unWindowTimers
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal WindowTimers where
+  pFromJSVal = WindowTimers
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal WindowTimers where
+  toJSVal = return . unWindowTimers
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal WindowTimers where
+  fromJSVal = return . fmap WindowTimers . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject WindowTimers where
+  typeGType _ = gTypeWindowTimers
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"WindowTimers\"]" gTypeWindowTimers :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.Worker".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/Worker Mozilla Worker documentation>
+newtype Worker = Worker { unWorker :: JSVal }
+
+instance Eq (Worker) where
+  (Worker a) == (Worker b) = js_eq a b
+
+instance PToJSVal Worker where
+  pToJSVal = unWorker
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal Worker where
+  pFromJSVal = Worker
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal Worker where
+  toJSVal = return . unWorker
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal Worker where
+  fromJSVal = return . fmap Worker . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsEventTarget Worker
+instance IsGObject Worker where
+  typeGType _ = gTypeWorker
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"Worker\"]" gTypeWorker :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.WorkerGlobalScope".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/WorkerGlobalScope Mozilla WorkerGlobalScope documentation>
+newtype WorkerGlobalScope = WorkerGlobalScope { unWorkerGlobalScope :: JSVal }
+
+instance Eq (WorkerGlobalScope) where
+  (WorkerGlobalScope a) == (WorkerGlobalScope b) = js_eq a b
+
+instance PToJSVal WorkerGlobalScope where
+  pToJSVal = unWorkerGlobalScope
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal WorkerGlobalScope where
+  pFromJSVal = WorkerGlobalScope
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal WorkerGlobalScope where
+  toJSVal = return . unWorkerGlobalScope
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal WorkerGlobalScope where
+  fromJSVal = return . fmap WorkerGlobalScope . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+class IsEventTarget o => IsWorkerGlobalScope o
+toWorkerGlobalScope :: IsWorkerGlobalScope o => o -> WorkerGlobalScope
+toWorkerGlobalScope = WorkerGlobalScope . coerce
+
+instance IsWorkerGlobalScope WorkerGlobalScope
+instance IsEventTarget WorkerGlobalScope
+instance IsGObject WorkerGlobalScope where
+  typeGType _ = gTypeWorkerGlobalScope
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"WorkerGlobalScope\"]" gTypeWorkerGlobalScope :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.WorkerLocation".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/WorkerLocation Mozilla WorkerLocation documentation>
+newtype WorkerLocation = WorkerLocation { unWorkerLocation :: JSVal }
+
+instance Eq (WorkerLocation) where
+  (WorkerLocation a) == (WorkerLocation b) = js_eq a b
+
+instance PToJSVal WorkerLocation where
+  pToJSVal = unWorkerLocation
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal WorkerLocation where
+  pFromJSVal = WorkerLocation
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal WorkerLocation where
+  toJSVal = return . unWorkerLocation
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal WorkerLocation where
+  fromJSVal = return . fmap WorkerLocation . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject WorkerLocation where
+  typeGType _ = gTypeWorkerLocation
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"WorkerLocation\"]" gTypeWorkerLocation :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.WorkerNavigator".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/WorkerNavigator Mozilla WorkerNavigator documentation>
+newtype WorkerNavigator = WorkerNavigator { unWorkerNavigator :: JSVal }
+
+instance Eq (WorkerNavigator) where
+  (WorkerNavigator a) == (WorkerNavigator b) = js_eq a b
+
+instance PToJSVal WorkerNavigator where
+  pToJSVal = unWorkerNavigator
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal WorkerNavigator where
+  pFromJSVal = WorkerNavigator
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal WorkerNavigator where
+  toJSVal = return . unWorkerNavigator
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal WorkerNavigator where
+  fromJSVal = return . fmap WorkerNavigator . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject WorkerNavigator where
+  typeGType _ = gTypeWorkerNavigator
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"WorkerNavigator\"]" gTypeWorkerNavigator :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.XMLHttpRequest".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest Mozilla XMLHttpRequest documentation>
+newtype XMLHttpRequest = XMLHttpRequest { unXMLHttpRequest :: JSVal }
+
+instance Eq (XMLHttpRequest) where
+  (XMLHttpRequest a) == (XMLHttpRequest b) = js_eq a b
+
+instance PToJSVal XMLHttpRequest where
+  pToJSVal = unXMLHttpRequest
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal XMLHttpRequest where
+  pFromJSVal = XMLHttpRequest
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal XMLHttpRequest where
+  toJSVal = return . unXMLHttpRequest
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal XMLHttpRequest where
+  fromJSVal = return . fmap XMLHttpRequest . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsEventTarget XMLHttpRequest
+instance IsGObject XMLHttpRequest where
+  typeGType _ = gTypeXMLHttpRequest
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"XMLHttpRequest\"]" gTypeXMLHttpRequest :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.XMLHttpRequestProgressEvent".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.ProgressEvent"
+--     * "GHCJS.DOM.Event"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequestProgressEvent Mozilla XMLHttpRequestProgressEvent documentation>
+newtype XMLHttpRequestProgressEvent = XMLHttpRequestProgressEvent { unXMLHttpRequestProgressEvent :: JSVal }
+
+instance Eq (XMLHttpRequestProgressEvent) where
+  (XMLHttpRequestProgressEvent a) == (XMLHttpRequestProgressEvent b) = js_eq a b
+
+instance PToJSVal XMLHttpRequestProgressEvent where
+  pToJSVal = unXMLHttpRequestProgressEvent
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal XMLHttpRequestProgressEvent where
+  pFromJSVal = XMLHttpRequestProgressEvent
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal XMLHttpRequestProgressEvent where
+  toJSVal = return . unXMLHttpRequestProgressEvent
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal XMLHttpRequestProgressEvent where
+  fromJSVal = return . fmap XMLHttpRequestProgressEvent . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsProgressEvent XMLHttpRequestProgressEvent
+instance IsEvent XMLHttpRequestProgressEvent
+instance IsGObject XMLHttpRequestProgressEvent where
+  typeGType _ = gTypeXMLHttpRequestProgressEvent
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"XMLHttpRequestProgressEvent\"]" gTypeXMLHttpRequestProgressEvent :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.XMLHttpRequestUpload".
+-- Base interface functions are in:
+--
+--     * "GHCJS.DOM.EventTarget"
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequestUpload Mozilla XMLHttpRequestUpload documentation>
+newtype XMLHttpRequestUpload = XMLHttpRequestUpload { unXMLHttpRequestUpload :: JSVal }
+
+instance Eq (XMLHttpRequestUpload) where
+  (XMLHttpRequestUpload a) == (XMLHttpRequestUpload b) = js_eq a b
+
+instance PToJSVal XMLHttpRequestUpload where
+  pToJSVal = unXMLHttpRequestUpload
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal XMLHttpRequestUpload where
+  pFromJSVal = XMLHttpRequestUpload
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal XMLHttpRequestUpload where
+  toJSVal = return . unXMLHttpRequestUpload
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal XMLHttpRequestUpload where
+  fromJSVal = return . fmap XMLHttpRequestUpload . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsEventTarget XMLHttpRequestUpload
+instance IsGObject XMLHttpRequestUpload where
+  typeGType _ = gTypeXMLHttpRequestUpload
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"XMLHttpRequestUpload\"]" gTypeXMLHttpRequestUpload :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.XMLSerializer".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/XMLSerializer Mozilla XMLSerializer documentation>
+newtype XMLSerializer = XMLSerializer { unXMLSerializer :: JSVal }
+
+instance Eq (XMLSerializer) where
+  (XMLSerializer a) == (XMLSerializer b) = js_eq a b
+
+instance PToJSVal XMLSerializer where
+  pToJSVal = unXMLSerializer
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal XMLSerializer where
+  pFromJSVal = XMLSerializer
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal XMLSerializer where
+  toJSVal = return . unXMLSerializer
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal XMLSerializer where
+  fromJSVal = return . fmap XMLSerializer . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject XMLSerializer where
+  typeGType _ = gTypeXMLSerializer
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"XMLSerializer\"]" gTypeXMLSerializer :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.XPathEvaluator".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/XPathEvaluator Mozilla XPathEvaluator documentation>
+newtype XPathEvaluator = XPathEvaluator { unXPathEvaluator :: JSVal }
+
+instance Eq (XPathEvaluator) where
+  (XPathEvaluator a) == (XPathEvaluator b) = js_eq a b
+
+instance PToJSVal XPathEvaluator where
+  pToJSVal = unXPathEvaluator
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal XPathEvaluator where
+  pFromJSVal = XPathEvaluator
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal XPathEvaluator where
+  toJSVal = return . unXPathEvaluator
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal XPathEvaluator where
+  fromJSVal = return . fmap XPathEvaluator . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject XPathEvaluator where
+  typeGType _ = gTypeXPathEvaluator
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"XPathEvaluator\"]" gTypeXPathEvaluator :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.XPathExpression".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/XPathExpression Mozilla XPathExpression documentation>
+newtype XPathExpression = XPathExpression { unXPathExpression :: JSVal }
+
+instance Eq (XPathExpression) where
+  (XPathExpression a) == (XPathExpression b) = js_eq a b
+
+instance PToJSVal XPathExpression where
+  pToJSVal = unXPathExpression
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal XPathExpression where
+  pFromJSVal = XPathExpression
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal XPathExpression where
+  toJSVal = return . unXPathExpression
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal XPathExpression where
+  fromJSVal = return . fmap XPathExpression . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject XPathExpression where
+  typeGType _ = gTypeXPathExpression
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"XPathExpression\"]" gTypeXPathExpression :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.XPathNSResolver".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/XPathNSResolver Mozilla XPathNSResolver documentation>
+newtype XPathNSResolver = XPathNSResolver { unXPathNSResolver :: JSVal }
+
+instance Eq (XPathNSResolver) where
+  (XPathNSResolver a) == (XPathNSResolver b) = js_eq a b
+
+instance PToJSVal XPathNSResolver where
+  pToJSVal = unXPathNSResolver
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal XPathNSResolver where
+  pFromJSVal = XPathNSResolver
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal XPathNSResolver where
+  toJSVal = return . unXPathNSResolver
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal XPathNSResolver where
+  fromJSVal = return . fmap XPathNSResolver . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject XPathNSResolver where
+  typeGType _ = gTypeXPathNSResolver
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"XPathNSResolver\"]" gTypeXPathNSResolver :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.XPathResult".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/XPathResult Mozilla XPathResult documentation>
+newtype XPathResult = XPathResult { unXPathResult :: JSVal }
+
+instance Eq (XPathResult) where
+  (XPathResult a) == (XPathResult b) = js_eq a b
+
+instance PToJSVal XPathResult where
+  pToJSVal = unXPathResult
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal XPathResult where
+  pFromJSVal = XPathResult
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal XPathResult where
+  toJSVal = return . unXPathResult
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal XPathResult where
+  fromJSVal = return . fmap XPathResult . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject XPathResult where
+  typeGType _ = gTypeXPathResult
+  {-# INLINE typeGType #-}
+foreign import javascript unsafe "window[\"XPathResult\"]" gTypeXPathResult :: GType
+
+-- | Functions for this inteface are in "GHCJS.DOM.XSLTProcessor".
+--
+-- <https://developer.mozilla.org/en-US/docs/Web/API/XSLTProcessor Mozilla XSLTProcessor documentation>
+newtype XSLTProcessor = XSLTProcessor { unXSLTProcessor :: JSVal }
+
+instance Eq (XSLTProcessor) where
+  (XSLTProcessor a) == (XSLTProcessor b) = js_eq a b
+
+instance PToJSVal XSLTProcessor where
+  pToJSVal = unXSLTProcessor
+  {-# INLINE pToJSVal #-}
+
+instance PFromJSVal XSLTProcessor where
+  pFromJSVal = XSLTProcessor
+  {-# INLINE pFromJSVal #-}
+
+instance ToJSVal XSLTProcessor where
+  toJSVal = return . unXSLTProcessor
+  {-# INLINE toJSVal #-}
+
+instance FromJSVal XSLTProcessor where
+  fromJSVal = return . fmap XSLTProcessor . maybeJSNullOrUndefined
+  {-# INLINE fromJSVal #-}
+
+instance IsGObject XSLTProcessor where
+  typeGType _ = gTypeXSLTProcessor
+  {-# INLINE typeGType #-}
 foreign import javascript unsafe "window[\"XSLTProcessor\"]" gTypeXSLTProcessor :: GType