{-# LANGUAGE ImplicitParams, RankNTypes, TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.JavaScriptCore.Objects.WeakValue
(
WeakValue(..) ,
IsWeakValue ,
toWeakValue ,
#if defined(ENABLE_OVERLOADING)
ResolveWeakValueMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
WeakValueGetValueMethodInfo ,
#endif
weakValueGetValue ,
weakValueNew ,
#if defined(ENABLE_OVERLOADING)
WeakValueValuePropertyInfo ,
#endif
constructWeakValueValue ,
#if defined(ENABLE_OVERLOADING)
weakValueValue ,
#endif
WeakValueClearedCallback ,
#if defined(ENABLE_OVERLOADING)
WeakValueClearedSignalInfo ,
#endif
afterWeakValueCleared ,
onWeakValueCleared ,
) where
import Data.GI.Base.ShortPrelude
import qualified Data.GI.Base.ShortPrelude as SP
import qualified Data.GI.Base.Overloading as O
import qualified Prelude as P
import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.BasicTypes as B.Types
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GArray as B.GArray
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GHashTable as B.GHT
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified Control.Monad.IO.Class as MIO
import qualified Data.Coerce as Coerce
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL
import qualified GHC.Records as R
import qualified GI.GObject.Objects.Object as GObject.Object
import {-# SOURCE #-} qualified GI.JavaScriptCore.Objects.Value as JavaScriptCore.Value
newtype WeakValue = WeakValue (SP.ManagedPtr WeakValue)
deriving (WeakValue -> WeakValue -> Bool
(WeakValue -> WeakValue -> Bool)
-> (WeakValue -> WeakValue -> Bool) -> Eq WeakValue
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: WeakValue -> WeakValue -> Bool
== :: WeakValue -> WeakValue -> Bool
$c/= :: WeakValue -> WeakValue -> Bool
/= :: WeakValue -> WeakValue -> Bool
Eq)
instance SP.ManagedPtrNewtype WeakValue where
toManagedPtr :: WeakValue -> ManagedPtr WeakValue
toManagedPtr (WeakValue ManagedPtr WeakValue
p) = ManagedPtr WeakValue
p
foreign import ccall "jsc_weak_value_get_type"
c_jsc_weak_value_get_type :: IO B.Types.GType
instance B.Types.TypedObject WeakValue where
glibType :: IO GType
glibType = IO GType
c_jsc_weak_value_get_type
instance B.Types.GObject WeakValue
class (SP.GObject o, O.IsDescendantOf WeakValue o) => IsWeakValue o
instance (SP.GObject o, O.IsDescendantOf WeakValue o) => IsWeakValue o
instance O.HasParentTypes WeakValue
type instance O.ParentTypes WeakValue = '[GObject.Object.Object]
toWeakValue :: (MIO.MonadIO m, IsWeakValue o) => o -> m WeakValue
toWeakValue :: forall (m :: * -> *) o.
(MonadIO m, IsWeakValue o) =>
o -> m WeakValue
toWeakValue = IO WeakValue -> m WeakValue
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO WeakValue -> m WeakValue)
-> (o -> IO WeakValue) -> o -> m WeakValue
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ManagedPtr WeakValue -> WeakValue) -> o -> IO WeakValue
forall o o'.
(HasCallStack, ManagedPtrNewtype o, TypedObject o,
ManagedPtrNewtype o', TypedObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
B.ManagedPtr.unsafeCastTo ManagedPtr WeakValue -> WeakValue
WeakValue
instance B.GValue.IsGValue (Maybe WeakValue) where
gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_jsc_weak_value_get_type
gvalueSet_ :: Ptr GValue -> Maybe WeakValue -> IO ()
gvalueSet_ Ptr GValue
gv Maybe WeakValue
P.Nothing = Ptr GValue -> Ptr WeakValue -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (Ptr WeakValue
forall a. Ptr a
FP.nullPtr :: FP.Ptr WeakValue)
gvalueSet_ Ptr GValue
gv (P.Just WeakValue
obj) = WeakValue -> (Ptr WeakValue -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr WeakValue
obj (Ptr GValue -> Ptr WeakValue -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
gvalueGet_ :: Ptr GValue -> IO (Maybe WeakValue)
gvalueGet_ Ptr GValue
gv = do
Ptr WeakValue
ptr <- Ptr GValue -> IO (Ptr WeakValue)
forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr WeakValue)
if Ptr WeakValue
ptr Ptr WeakValue -> Ptr WeakValue -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr WeakValue
forall a. Ptr a
FP.nullPtr
then WeakValue -> Maybe WeakValue
forall a. a -> Maybe a
P.Just (WeakValue -> Maybe WeakValue)
-> IO WeakValue -> IO (Maybe WeakValue)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr WeakValue -> WeakValue)
-> Ptr WeakValue -> IO WeakValue
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr WeakValue -> WeakValue
WeakValue Ptr WeakValue
ptr
else Maybe WeakValue -> IO (Maybe WeakValue)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe WeakValue
forall a. Maybe a
P.Nothing
#if defined(ENABLE_OVERLOADING)
type family ResolveWeakValueMethod (t :: Symbol) (o :: *) :: * where
ResolveWeakValueMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
ResolveWeakValueMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
ResolveWeakValueMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
ResolveWeakValueMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
ResolveWeakValueMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
ResolveWeakValueMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
ResolveWeakValueMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
ResolveWeakValueMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
ResolveWeakValueMethod "ref" o = GObject.Object.ObjectRefMethodInfo
ResolveWeakValueMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
ResolveWeakValueMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
ResolveWeakValueMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
ResolveWeakValueMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
ResolveWeakValueMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
ResolveWeakValueMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
ResolveWeakValueMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
ResolveWeakValueMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
ResolveWeakValueMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
ResolveWeakValueMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
ResolveWeakValueMethod "getValue" o = WeakValueGetValueMethodInfo
ResolveWeakValueMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
ResolveWeakValueMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
ResolveWeakValueMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
ResolveWeakValueMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveWeakValueMethod t WeakValue, O.OverloadedMethod info WeakValue p) => OL.IsLabel t (WeakValue -> p) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.overloadedMethod @info
#else
fromLabel _ = O.overloadedMethod @info
#endif
#if MIN_VERSION_base(4,13,0)
instance (info ~ ResolveWeakValueMethod t WeakValue, O.OverloadedMethod info WeakValue p, R.HasField t WeakValue p) => R.HasField t WeakValue p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveWeakValueMethod t WeakValue, O.OverloadedMethodInfo info WeakValue) => OL.IsLabel t (O.MethodProxy info WeakValue) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif
type WeakValueClearedCallback =
IO ()
type C_WeakValueClearedCallback =
Ptr WeakValue ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mk_WeakValueClearedCallback :: C_WeakValueClearedCallback -> IO (FunPtr C_WeakValueClearedCallback)
wrap_WeakValueClearedCallback ::
GObject a => (a -> WeakValueClearedCallback) ->
C_WeakValueClearedCallback
wrap_WeakValueClearedCallback :: forall a. GObject a => (a -> IO ()) -> C_WeakValueClearedCallback
wrap_WeakValueClearedCallback a -> IO ()
gi'cb Ptr WeakValue
gi'selfPtr Ptr ()
_ = do
Ptr WeakValue -> (WeakValue -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr WeakValue
gi'selfPtr ((WeakValue -> IO ()) -> IO ()) -> (WeakValue -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \WeakValue
gi'self -> a -> IO ()
gi'cb (WeakValue -> a
forall a b. Coercible a b => a -> b
Coerce.coerce WeakValue
gi'self)
onWeakValueCleared :: (IsWeakValue a, MonadIO m) => a -> ((?self :: a) => WeakValueClearedCallback) -> m SignalHandlerId
onWeakValueCleared :: forall a (m :: * -> *).
(IsWeakValue a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
onWeakValueCleared a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
let wrapped' :: C_WeakValueClearedCallback
wrapped' = (a -> IO ()) -> C_WeakValueClearedCallback
forall a. GObject a => (a -> IO ()) -> C_WeakValueClearedCallback
wrap_WeakValueClearedCallback a -> IO ()
wrapped
FunPtr C_WeakValueClearedCallback
wrapped'' <- C_WeakValueClearedCallback
-> IO (FunPtr C_WeakValueClearedCallback)
mk_WeakValueClearedCallback C_WeakValueClearedCallback
wrapped'
a
-> Text
-> FunPtr C_WeakValueClearedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"cleared" FunPtr C_WeakValueClearedCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing
afterWeakValueCleared :: (IsWeakValue a, MonadIO m) => a -> ((?self :: a) => WeakValueClearedCallback) -> m SignalHandlerId
afterWeakValueCleared :: forall a (m :: * -> *).
(IsWeakValue a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
afterWeakValueCleared a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
let wrapped' :: C_WeakValueClearedCallback
wrapped' = (a -> IO ()) -> C_WeakValueClearedCallback
forall a. GObject a => (a -> IO ()) -> C_WeakValueClearedCallback
wrap_WeakValueClearedCallback a -> IO ()
wrapped
FunPtr C_WeakValueClearedCallback
wrapped'' <- C_WeakValueClearedCallback
-> IO (FunPtr C_WeakValueClearedCallback)
mk_WeakValueClearedCallback C_WeakValueClearedCallback
wrapped'
a
-> Text
-> FunPtr C_WeakValueClearedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"cleared" FunPtr C_WeakValueClearedCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing
#if defined(ENABLE_OVERLOADING)
data WeakValueClearedSignalInfo
instance SignalInfo WeakValueClearedSignalInfo where
type HaskellCallbackType WeakValueClearedSignalInfo = WeakValueClearedCallback
connectSignal obj cb connectMode detail = do
let cb' = wrap_WeakValueClearedCallback cb
cb'' <- mk_WeakValueClearedCallback cb'
connectSignalFunPtr obj "cleared" cb'' connectMode detail
dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.JavaScriptCore.Objects.WeakValue::cleared"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-javascriptcore-4.0.25/docs/GI-JavaScriptCore-Objects-WeakValue.html#g:signal:cleared"})
#endif
constructWeakValueValue :: (IsWeakValue o, MIO.MonadIO m, JavaScriptCore.Value.IsValue a) => a -> m (GValueConstruct o)
constructWeakValueValue :: forall o (m :: * -> *) a.
(IsWeakValue o, MonadIO m, IsValue a) =>
a -> m (GValueConstruct o)
constructWeakValueValue a
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Maybe a -> IO (GValueConstruct o)
forall a o.
GObject a =>
String -> Maybe a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyObject String
"value" (a -> Maybe a
forall a. a -> Maybe a
P.Just a
val)
#if defined(ENABLE_OVERLOADING)
data WeakValueValuePropertyInfo
instance AttrInfo WeakValueValuePropertyInfo where
type AttrAllowedOps WeakValueValuePropertyInfo = '[ 'AttrConstruct, 'AttrClear]
type AttrBaseTypeConstraint WeakValueValuePropertyInfo = IsWeakValue
type AttrSetTypeConstraint WeakValueValuePropertyInfo = JavaScriptCore.Value.IsValue
type AttrTransferTypeConstraint WeakValueValuePropertyInfo = JavaScriptCore.Value.IsValue
type AttrTransferType WeakValueValuePropertyInfo = JavaScriptCore.Value.Value
type AttrGetType WeakValueValuePropertyInfo = ()
type AttrLabel WeakValueValuePropertyInfo = "value"
type AttrOrigin WeakValueValuePropertyInfo = WeakValue
attrGet = undefined
attrSet = undefined
attrTransfer _ v = do
unsafeCastTo JavaScriptCore.Value.Value v
attrConstruct = constructWeakValueValue
attrClear = undefined
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.JavaScriptCore.Objects.WeakValue.value"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-javascriptcore-4.0.25/docs/GI-JavaScriptCore-Objects-WeakValue.html#g:attr:value"
})
#endif
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList WeakValue
type instance O.AttributeList WeakValue = WeakValueAttributeList
type WeakValueAttributeList = ('[ '("value", WeakValueValuePropertyInfo)] :: [(Symbol, *)])
#endif
#if defined(ENABLE_OVERLOADING)
weakValueValue :: AttrLabelProxy "value"
weakValueValue = AttrLabelProxy
#endif
#if defined(ENABLE_OVERLOADING)
type instance O.SignalList WeakValue = WeakValueSignalList
type WeakValueSignalList = ('[ '("cleared", WeakValueClearedSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])
#endif
foreign import ccall "jsc_weak_value_new" jsc_weak_value_new ::
Ptr JavaScriptCore.Value.Value ->
IO (Ptr WeakValue)
weakValueNew ::
(B.CallStack.HasCallStack, MonadIO m, JavaScriptCore.Value.IsValue a) =>
a
-> m WeakValue
weakValueNew :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsValue a) =>
a -> m WeakValue
weakValueNew a
value = IO WeakValue -> m WeakValue
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO WeakValue -> m WeakValue) -> IO WeakValue -> m WeakValue
forall a b. (a -> b) -> a -> b
$ do
Ptr Value
value' <- a -> IO (Ptr Value)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
value
Ptr WeakValue
result <- Ptr Value -> IO (Ptr WeakValue)
jsc_weak_value_new Ptr Value
value'
Text -> Ptr WeakValue -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"weakValueNew" Ptr WeakValue
result
WeakValue
result' <- ((ManagedPtr WeakValue -> WeakValue)
-> Ptr WeakValue -> IO WeakValue
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr WeakValue -> WeakValue
WeakValue) Ptr WeakValue
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
value
WeakValue -> IO WeakValue
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return WeakValue
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "jsc_weak_value_get_value" jsc_weak_value_get_value ::
Ptr WeakValue ->
IO (Ptr JavaScriptCore.Value.Value)
weakValueGetValue ::
(B.CallStack.HasCallStack, MonadIO m, IsWeakValue a) =>
a
-> m JavaScriptCore.Value.Value
weakValueGetValue :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWeakValue a) =>
a -> m Value
weakValueGetValue a
weakValue = IO Value -> m Value
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Value -> m Value) -> IO Value -> m Value
forall a b. (a -> b) -> a -> b
$ do
Ptr WeakValue
weakValue' <- a -> IO (Ptr WeakValue)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
weakValue
Ptr Value
result <- Ptr WeakValue -> IO (Ptr Value)
jsc_weak_value_get_value Ptr WeakValue
weakValue'
Text -> Ptr Value -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"weakValueGetValue" Ptr Value
result
Value
result' <- ((ManagedPtr Value -> Value) -> Ptr Value -> IO Value
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr Value -> Value
JavaScriptCore.Value.Value) Ptr Value
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
weakValue
Value -> IO Value
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Value
result'
#if defined(ENABLE_OVERLOADING)
data WeakValueGetValueMethodInfo
instance (signature ~ (m JavaScriptCore.Value.Value), MonadIO m, IsWeakValue a) => O.OverloadedMethod WeakValueGetValueMethodInfo a signature where
overloadedMethod = weakValueGetValue
instance O.OverloadedMethodInfo WeakValueGetValueMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.JavaScriptCore.Objects.WeakValue.weakValueGetValue",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-javascriptcore-4.0.25/docs/GI-JavaScriptCore-Objects-WeakValue.html#v:weakValueGetValue"
})
#endif