diff --git a/lib/PuppeteerSharp/Cdp/CdpElementHandle.cs b/lib/PuppeteerSharp/Cdp/CdpElementHandle.cs
new file mode 100644
index 000000000..bb9274f78
--- /dev/null
+++ b/lib/PuppeteerSharp/Cdp/CdpElementHandle.cs
@@ -0,0 +1,175 @@
+// * MIT License
+//  *
+//  * Copyright (c) Darío Kondratiuk
+//  *
+//  * Permission is hereby granted, free of charge, to any person obtaining a copy
+//  * of this software and associated documentation files (the "Software"), to deal
+//  * in the Software without restriction, including without limitation the rights
+//  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//  * copies of the Software, and to permit persons to whom the Software is
+//  * furnished to do so, subject to the following conditions:
+//  *
+//  * The above copyright notice and this permission notice shall be included in all
+//  * copies or substantial portions of the Software.
+//  *
+//  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+//  * SOFTWARE.
+
+using System;
+using System.IO;
+using System.Linq;
+using System.Threading.Tasks;
+using Microsoft.Extensions.Logging;
+using PuppeteerSharp.Messaging;
+using PuppeteerSharp.QueryHandlers;
+
+namespace PuppeteerSharp.Cdp;
+
+/// <inheritdoc />
+public class CdpElementHandle : ElementHandle
+{
+    internal CdpElementHandle(
+        IsolatedWorld world,
+        RemoteObject remoteObject) : base(world, remoteObject)
+    {
+        Handle = new CdpJSHandle(world, remoteObject);
+        Logger = Realm.Environment.Client.Connection.LoggerFactory.CreateLogger(GetType());
+    }
+
+    /// <summary>
+    /// Logger.
+    /// </summary>
+    internal ILogger Logger { get; }
+
+    internal override CustomQuerySelectorRegistry CustomQuerySelectorRegistry =>
+        Client.Connection.CustomQuerySelectorRegistry;
+
+    /// <inheritdoc/>
+    protected override Page Page => Frame.FrameManager.Page;
+
+    private CDPSession Client => Handle.Realm.Environment.Client;
+
+    private FrameManager FrameManager => Frame.FrameManager;
+
+    /// <inheritdoc/>
+    public override async Task<IFrame> ContentFrameAsync()
+    {
+        var nodeInfo = await Client
+            .SendAsync<DomDescribeNodeResponse>("DOM.describeNode", new DomDescribeNodeRequest { ObjectId = Id, })
+            .ConfigureAwait(false);
+
+        return string.IsNullOrEmpty(nodeInfo.Node.FrameId)
+            ? null
+            : await FrameManager.FrameTree.GetFrameAsync(nodeInfo.Node.FrameId).ConfigureAwait(false);
+    }
+
+    /// <inheritdoc/>
+    public override Task ScrollIntoViewAsync()
+        => BindIsolatedHandleAsync<IElementHandle, CdpElementHandle>(async handle =>
+        {
+            await handle.AssertConnectedElementAsync().ConfigureAwait(false);
+            try
+            {
+                await handle.Client
+                    .SendAsync(
+                        "DOM.scrollIntoViewIfNeeded",
+                        new DomScrollIntoViewIfNeededRequest { ObjectId = Id, })
+                    .ConfigureAwait(false);
+            }
+            catch (Exception ex)
+            {
+                Logger.LogError(ex, "DOM.scrollIntoViewIfNeeded is not supported");
+                await base.ScrollIntoViewAsync().ConfigureAwait(false);
+            }
+
+            return handle;
+        });
+
+    /// <inheritdoc />
+    public override Task UploadFileAsync(bool resolveFilePaths, params string[] filePaths)
+            => BindIsolatedHandleAsync<CdpElementHandle, CdpElementHandle>(async handle =>
+            {
+                var isMultiple = await EvaluateFunctionAsync<bool>("element => element.multiple").ConfigureAwait(false);
+
+                if (!isMultiple && filePaths.Length > 1)
+                {
+                    throw new PuppeteerException("Multiple file uploads only work with <input type=file multiple>");
+                }
+
+                // The zero-length array is a special case, it seems that
+                // DOM.setFileInputFiles does not actually update the files in that case, so
+                // the solution is to eval the element value to a new FileList directly.
+                if (!filePaths.Any())
+                {
+                    await handle.EvaluateFunctionAsync(@"(element) => {
+                        element.files = new DataTransfer().files;
+
+                        // Dispatch events for this case because it should behave akin to a user action.
+                        element.dispatchEvent(
+                            new Event('input', {bubbles: true, composed: true})
+                        );
+                        element.dispatchEvent(new Event('change', { bubbles: true }));
+                    }").ConfigureAwait(false);
+
+                    return handle;
+                }
+
+                var node = await handle.Client
+                    .SendAsync<DomDescribeNodeResponse>(
+                        "DOM.describeNode",
+                        new DomDescribeNodeRequest { ObjectId = Id, }).ConfigureAwait(false);
+                var backendNodeId = node.Node.BackendNodeId;
+
+                var files = resolveFilePaths ? filePaths.Select(Path.GetFullPath).ToArray() : filePaths;
+                CheckForFileAccess(files);
+                await handle.Client.SendAsync(
+                    "DOM.setFileInputFiles",
+                    new DomSetFileInputFilesRequest
+                    {
+                        ObjectId = Id,
+                        Files = files,
+                        BackendNodeId = backendNodeId,
+                    })
+                    .ConfigureAwait(false);
+
+                return handle;
+            });
+
+    /// <inheritdoc />
+    public override ValueTask DisposeAsync()
+    {
+        if (Disposed)
+        {
+            return default;
+        }
+
+        Disposed = true;
+
+        Handle.DisposeAsync();
+        GC.SuppressFinalize(this);
+        return default;
+    }
+
+    /// <inheritdoc />
+    public override string ToString() => Handle.ToString();
+
+    private void CheckForFileAccess(string[] files)
+    {
+        foreach (var file in files)
+        {
+            try
+            {
+                File.Open(file, FileMode.Open).Dispose();
+            }
+            catch (Exception ex)
+            {
+                throw new PuppeteerException($"{files} does not exist or is not readable", ex);
+            }
+        }
+    }
+}
diff --git a/lib/PuppeteerSharp/Cdp/CdpJSHandle.cs b/lib/PuppeteerSharp/Cdp/CdpJSHandle.cs
new file mode 100644
index 000000000..1ea77d5dc
--- /dev/null
+++ b/lib/PuppeteerSharp/Cdp/CdpJSHandle.cs
@@ -0,0 +1,96 @@
+// * MIT License
+//  *
+//  * Copyright (c) Darío Kondratiuk
+//  *
+//  * Permission is hereby granted, free of charge, to any person obtaining a copy
+//  * of this software and associated documentation files (the "Software"), to deal
+//  * in the Software without restriction, including without limitation the rights
+//  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//  * copies of the Software, and to permit persons to whom the Software is
+//  * furnished to do so, subject to the following conditions:
+//  *
+//  * The above copyright notice and this permission notice shall be included in all
+//  * copies or substantial portions of the Software.
+//  *
+//  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+//  * SOFTWARE.
+
+using System;
+using System.Threading.Tasks;
+using Microsoft.Extensions.Logging;
+using Newtonsoft.Json;
+using PuppeteerSharp.Helpers;
+using PuppeteerSharp.Helpers.Json;
+using PuppeteerSharp.Messaging;
+
+namespace PuppeteerSharp.Cdp;
+
+/// <inheritdoc/>
+[JsonConverter(typeof(JSHandleMethodConverter))]
+public class CdpJSHandle : JSHandle
+{
+    internal CdpJSHandle(IsolatedWorld world, RemoteObject remoteObject) : base(world, remoteObject)
+    {
+        Logger = Client.Connection.LoggerFactory.CreateLogger(GetType());
+    }
+
+    /// <summary>
+    /// Logger.
+    /// </summary>
+    private ILogger Logger { get; }
+
+    private CDPSession Client => Realm.Environment.Client;
+
+    /// <inheritdoc/>
+    public override async Task<T> JsonValueAsync<T>()
+    {
+        var objectId = RemoteObject.ObjectId;
+
+        if (objectId == null)
+        {
+            return (T)RemoteObjectHelper.ValueFromRemoteObject<T>(RemoteObject);
+        }
+
+        var value = await EvaluateFunctionAsync<T>("object => object").ConfigureAwait(false);
+
+        return value == null ? throw new PuppeteerException("Could not serialize referenced object") : value;
+    }
+
+    /// <inheritdoc/>
+    public override async ValueTask DisposeAsync()
+    {
+        if (Disposed)
+        {
+            return;
+        }
+
+        Disposed = true;
+
+        if (DisposeAction != null)
+        {
+            await DisposeAction().ConfigureAwait(false);
+        }
+
+        await RemoteObjectHelper.ReleaseObjectAsync(Client, RemoteObject, Logger).ConfigureAwait(false);
+        GC.SuppressFinalize(this);
+    }
+
+    /// <inheritdoc/>
+    public override string ToString()
+    {
+        if (RemoteObject.ObjectId == null)
+        {
+            return "JSHandle:" + RemoteObjectHelper.ValueFromRemoteObject<object>(RemoteObject, true);
+        }
+
+        var type = RemoteObject.Subtype != RemoteObjectSubtype.Other
+            ? RemoteObject.Subtype.ToString()
+            : RemoteObject.Type.ToString();
+        return "JSHandle@" + type.ToLower(System.Globalization.CultureInfo.CurrentCulture);
+    }
+}
diff --git a/lib/PuppeteerSharp/Cdp/CdpWebWorker.cs b/lib/PuppeteerSharp/Cdp/CdpWebWorker.cs
index b95e24705..5e6c73037 100644
--- a/lib/PuppeteerSharp/Cdp/CdpWebWorker.cs
+++ b/lib/PuppeteerSharp/Cdp/CdpWebWorker.cs
@@ -147,7 +147,7 @@ private async Task OnConsoleAPICalledAsync(MessageEventArgs e)
         var consoleData = e.MessageData.ToObject<PageConsoleResponse>(true);
         await _consoleAPICalled(
             consoleData.Type,
-            consoleData.Args.Select(i => new JSHandle(World, i)).ToArray(),
+            consoleData.Args.Select(i => new CdpJSHandle(World, i)).ToArray(),
             consoleData.StackTrace)
                 .ConfigureAwait(false);
     }
diff --git a/lib/PuppeteerSharp/ElementHandle.cs b/lib/PuppeteerSharp/ElementHandle.cs
index da723f131..0641bf30f 100644
--- a/lib/PuppeteerSharp/ElementHandle.cs
+++ b/lib/PuppeteerSharp/ElementHandle.cs
@@ -5,7 +5,7 @@
 using System.IO;
 using System.Linq;
 using System.Threading.Tasks;
-using Microsoft.Extensions.Logging;
+using Newtonsoft.Json.Linq;
 using PuppeteerSharp.Helpers;
 using PuppeteerSharp.Input;
 using PuppeteerSharp.Messaging;
@@ -15,26 +15,28 @@ namespace PuppeteerSharp
 {
     /// <inheritdoc cref="PuppeteerSharp.IElementHandle" />
     [DebuggerDisplay("{DebuggerDisplay,nq}")]
-    public class ElementHandle : JSHandle, IElementHandle
+    public abstract class ElementHandle : JSHandle, IElementHandle
     {
         internal ElementHandle(
             IsolatedWorld world,
             RemoteObject remoteObject) : base(world, remoteObject)
         {
-            Handle = new JSHandle(world, remoteObject);
         }
 
         /// <inheritdoc/>
         IFrame IElementHandle.Frame => Frame;
 
-        private JSHandle Handle { get; }
+        internal abstract CustomQuerySelectorRegistry CustomQuerySelectorRegistry { get; }
 
-        private CustomQuerySelectorRegistry CustomQuerySelectorRegistry =>
-            Client.Connection.CustomQuerySelectorRegistry;
+        /// <summary>
+        /// Base handle.
+        /// </summary>
+        protected JSHandle Handle { get; init; }
 
-        private FrameManager FrameManager => Frame.FrameManager;
-
-        private Page Page => Frame.FrameManager.Page;
+        /// <summary>
+        /// Element's page.
+        /// </summary>
+        protected abstract Page Page { get; }
 
         private string DebuggerDisplay =>
             string.IsNullOrEmpty(RemoteObject.ClassName)
@@ -79,7 +81,7 @@ public async Task<IElementHandle> WaitForSelectorAsync(string selector, WaitForS
             }
 
             var (updatedSelector, queryHandler) = CustomQuerySelectorRegistry.GetQueryHandlerAndSelector(selector);
-            return await BindIsolatedHandleAsync(handle =>
+            return await BindIsolatedHandleAsync<IElementHandle, ElementHandle>(handle =>
                 queryHandler.WaitForAsync(null, handle, updatedSelector, options)).ConfigureAwait(false);
         }
 
@@ -92,7 +94,7 @@ public async Task<byte[]> ScreenshotDataAsync(ElementScreenshotOptions options)
 
         /// <inheritdoc/>
         public Task<string> ScreenshotBase64Async(ElementScreenshotOptions options)
-            => BindIsolatedHandleAsync(async handle =>
+            => BindIsolatedHandleAsync<string, ElementHandle>(async handle =>
             {
                 if (options == null)
                 {
@@ -100,7 +102,7 @@ public Task<string> ScreenshotBase64Async(ElementScreenshotOptions options)
                 }
 
                 var clip = await handle.NonEmptyVisibleBoundingBoxAsync().ConfigureAwait(false);
-                var page = handle.FrameManager.Page;
+                var page = handle.Page;
 
                 if (options.ScrollIntoView)
                 {
@@ -130,7 +132,7 @@ public Task<string> ScreenshotBase64Async(ElementScreenshotOptions options)
 
         /// <inheritdoc/>
         public Task HoverAsync()
-            => BindIsolatedHandleAsync(async handle =>
+            => BindIsolatedHandleAsync<IElementHandle, ElementHandle>(async handle =>
             {
                 await handle.ScrollIntoViewIfNeededAsync().ConfigureAwait(false);
                 var clickablePoint = await handle.ClickablePointAsync().ConfigureAwait(false);
@@ -140,7 +142,7 @@ public Task HoverAsync()
 
         /// <inheritdoc/>
         public Task ClickAsync(ClickOptions options = null)
-            => BindIsolatedHandleAsync(async handle =>
+            => BindIsolatedHandleAsync<IElementHandle, ElementHandle>(async handle =>
             {
                 await handle.ScrollIntoViewIfNeededAsync().ConfigureAwait(false);
                 var clickablePoint = await handle.ClickablePointAsync(options?.OffSet).ConfigureAwait(false);
@@ -152,58 +154,11 @@ public Task ClickAsync(ClickOptions options = null)
         public Task UploadFileAsync(params string[] filePaths) => UploadFileAsync(true, filePaths);
 
         /// <inheritdoc/>
-        public Task UploadFileAsync(bool resolveFilePaths, params string[] filePaths)
-            => BindIsolatedHandleAsync(async handle =>
-            {
-                var isMultiple = await EvaluateFunctionAsync<bool>("element => element.multiple").ConfigureAwait(false);
-
-                if (!isMultiple && filePaths.Length > 1)
-                {
-                    throw new PuppeteerException("Multiple file uploads only work with <input type=file multiple>");
-                }
-
-                // The zero-length array is a special case, it seems that
-                // DOM.setFileInputFiles does not actually update the files in that case, so
-                // the solution is to eval the element value to a new FileList directly.
-                if (!filePaths.Any())
-                {
-                    await handle.EvaluateFunctionAsync(@"(element) => {
-                        element.files = new DataTransfer().files;
-
-                        // Dispatch events for this case because it should behave akin to a user action.
-                        element.dispatchEvent(
-                            new Event('input', {bubbles: true, composed: true})
-                        );
-                        element.dispatchEvent(new Event('change', { bubbles: true }));
-                    }").ConfigureAwait(false);
-
-                    return handle;
-                }
-
-                var node = await handle.Client
-                    .SendAsync<DomDescribeNodeResponse>(
-                        "DOM.describeNode",
-                        new DomDescribeNodeRequest { ObjectId = Id, }).ConfigureAwait(false);
-                var backendNodeId = node.Node.BackendNodeId;
-
-                var files = resolveFilePaths ? filePaths.Select(Path.GetFullPath).ToArray() : filePaths;
-                CheckForFileAccess(files);
-                await handle.Client.SendAsync(
-                    "DOM.setFileInputFiles",
-                    new DomSetFileInputFilesRequest
-                    {
-                        ObjectId = Id,
-                        Files = files,
-                        BackendNodeId = backendNodeId,
-                    })
-                    .ConfigureAwait(false);
-
-                return handle;
-            });
+        public abstract Task UploadFileAsync(bool resolveFilePaths, params string[] filePaths);
 
         /// <inheritdoc/>
         public Task TapAsync()
-            => BindIsolatedHandleAsync(async handle =>
+            => BindIsolatedHandleAsync<IElementHandle, ElementHandle>(async handle =>
             {
                 await handle.ScrollIntoViewIfNeededAsync().ConfigureAwait(false);
                 var clickablePoint = await handle.ClickablePointAsync().ConfigureAwait(false);
@@ -213,7 +168,7 @@ public Task TapAsync()
 
         /// <inheritdoc/>
         public Task TouchStartAsync()
-            => BindIsolatedHandleAsync(async handle =>
+            => BindIsolatedHandleAsync<IElementHandle, ElementHandle>(async handle =>
             {
                 await handle.ScrollIntoViewIfNeededAsync().ConfigureAwait(false);
                 var clickablePoint = await handle.ClickablePointAsync().ConfigureAwait(false);
@@ -223,7 +178,7 @@ public Task TouchStartAsync()
 
         /// <inheritdoc/>
         public Task TouchMoveAsync()
-            => BindIsolatedHandleAsync(async handle =>
+            => BindIsolatedHandleAsync<IElementHandle, ElementHandle>(async handle =>
             {
                 await handle.ScrollIntoViewIfNeededAsync().ConfigureAwait(false);
                 var clickablePoint = await handle.ClickablePointAsync().ConfigureAwait(false);
@@ -233,7 +188,7 @@ public Task TouchMoveAsync()
 
         /// <inheritdoc/>
         public Task TouchEndAsync()
-            => BindIsolatedHandleAsync(async handle =>
+            => BindIsolatedHandleAsync<IElementHandle, ElementHandle>(async handle =>
             {
                 await handle.ScrollIntoViewIfNeededAsync().ConfigureAwait(false);
                 await Page.Touchscreen.TouchEndAsync().ConfigureAwait(false);
@@ -242,11 +197,11 @@ public Task TouchEndAsync()
 
         /// <inheritdoc/>
         public Task FocusAsync() =>
-            BindIsolatedHandleAsync(handle => handle.EvaluateFunctionAsync("element => element.focus()"));
+            BindIsolatedHandleAsync<JToken, ElementHandle>(handle => handle.EvaluateFunctionAsync("element => element.focus()"));
 
         /// <inheritdoc/>
         public Task TypeAsync(string text, TypeOptions options = null)
-            => BindIsolatedHandleAsync(async handle =>
+            => BindIsolatedHandleAsync<IElementHandle, ElementHandle>(async handle =>
             {
                 await handle.FocusAsync().ConfigureAwait(false);
                 await Page.Keyboard.TypeAsync(text, options).ConfigureAwait(false);
@@ -255,7 +210,7 @@ public Task TypeAsync(string text, TypeOptions options = null)
 
         /// <inheritdoc/>
         public Task PressAsync(string key, PressOptions options = null)
-            => BindIsolatedHandleAsync(async handle =>
+            => BindIsolatedHandleAsync<IElementHandle, ElementHandle>(async handle =>
             {
                 await handle.FocusAsync().ConfigureAwait(false);
                 await Page.Keyboard.PressAsync(key, options).ConfigureAwait(false);
@@ -264,7 +219,7 @@ public Task PressAsync(string key, PressOptions options = null)
 
         /// <inheritdoc/>
         public Task<IElementHandle> QuerySelectorAsync(string selector)
-            => BindIsolatedHandleAsync(handle =>
+            => BindIsolatedHandleAsync<IElementHandle, ElementHandle>(handle =>
             {
                 if (string.IsNullOrEmpty(selector))
                 {
@@ -277,7 +232,7 @@ public Task<IElementHandle> QuerySelectorAsync(string selector)
 
         /// <inheritdoc/>
         public Task<IElementHandle[]> QuerySelectorAllAsync(string selector)
-            => BindIsolatedHandleAsync(async handle =>
+            => BindIsolatedHandleAsync<IElementHandle[], ElementHandle>(async handle =>
             {
                 if (string.IsNullOrEmpty(selector))
                 {
@@ -335,12 +290,12 @@ public Task<IElementHandle[]> XPathAsync(string expression)
                 expression = $".{expression}";
             }
 
-            return BindIsolatedHandleAsync(handle => handle.QuerySelectorAllAsync($"xpath/{expression}"));
+            return BindIsolatedHandleAsync<IElementHandle[], ElementHandle>(handle => handle.QuerySelectorAllAsync($"xpath/{expression}"));
         }
 
         /// <inheritdoc/>
         public Task<BoundingBox> BoundingBoxAsync()
-            => BindIsolatedHandleAsync(async handle =>
+            => BindIsolatedHandleAsync<BoundingBox, ElementHandle>(async handle =>
             {
                 var box = await handle.EvaluateFunctionAsync<BoundingBox>(@"element => {
                     if (!(element instanceof Element)) {
@@ -377,7 +332,7 @@ public Task<BoundingBox> BoundingBoxAsync()
 
         /// <inheritdoc/>
         public Task<BoxModel> BoxModelAsync()
-            => BindIsolatedHandleAsync(async handle =>
+            => BindIsolatedHandleAsync<BoxModel, ElementHandle>(async handle =>
             {
                 var model = await handle.EvaluateFunctionAsync<BoxModel>(@"element => {
                     if (!(element instanceof Element)) {
@@ -492,20 +447,11 @@ function transformQuadWithOffsets(
             });
 
         /// <inheritdoc/>
-        public async Task<IFrame> ContentFrameAsync()
-        {
-            var nodeInfo = await Client
-                .SendAsync<DomDescribeNodeResponse>("DOM.describeNode", new DomDescribeNodeRequest { ObjectId = Id, })
-                .ConfigureAwait(false);
-
-            return string.IsNullOrEmpty(nodeInfo.Node.FrameId)
-                ? null
-                : await FrameManager.FrameTree.GetFrameAsync(nodeInfo.Node.FrameId).ConfigureAwait(false);
-        }
+        public abstract Task<IFrame> ContentFrameAsync();
 
         /// <inheritdoc/>
         public Task<bool> IsIntersectingViewportAsync(int threshold)
-            => BindIsolatedHandleAsync(async handle =>
+            => BindIsolatedHandleAsync<bool, ElementHandle>(async handle =>
             {
                 await handle.AssertConnectedElementAsync().ConfigureAwait(false);
                 return await handle.Realm.EvaluateFunctionAsync<bool>(
@@ -525,7 +471,7 @@ public Task<bool> IsIntersectingViewportAsync(int threshold)
 
         /// <inheritdoc/>
         public Task<string[]> SelectAsync(params string[] values)
-            => BindIsolatedHandleAsync(handle => handle.EvaluateFunctionAsync<string[]>(
+            => BindIsolatedHandleAsync<string[], ElementHandle>(handle => handle.EvaluateFunctionAsync<string[]>(
                 @"(element, values) =>
                     {
                         if (element.nodeName.toLowerCase() !== 'select')
@@ -546,7 +492,7 @@ public Task<string[]> SelectAsync(params string[] values)
 
         /// <inheritdoc/>
         public Task<DragData> DragAsync(decimal x, decimal y)
-            => BindIsolatedHandleAsync(async handle =>
+            => BindIsolatedHandleAsync<DragData, ElementHandle>(async handle =>
             {
                 await handle.ScrollIntoViewIfNeededAsync().ConfigureAwait(false);
 
@@ -579,7 +525,7 @@ public Task<DragData> DragAsync(decimal x, decimal y)
 
         /// <inheritdoc/>
         public Task<DragData> DragAsync(IElementHandle target)
-            => BindIsolatedHandleAsync(async handle =>
+            => BindIsolatedHandleAsync<DragData, ElementHandle>(async handle =>
             {
                 if (target == null)
                 {
@@ -617,7 +563,7 @@ public Task<DragData> DragAsync(IElementHandle target)
 
         /// <inheritdoc/>
         public Task DragEnterAsync(DragData data)
-            => BindIsolatedHandleAsync(async handle =>
+            => BindIsolatedHandleAsync<IElementHandle, ElementHandle>(async handle =>
             {
                 await handle.ScrollIntoViewIfNeededAsync().ConfigureAwait(false);
                 var clickablePoint = await handle.ClickablePointAsync().ConfigureAwait(false);
@@ -627,7 +573,7 @@ public Task DragEnterAsync(DragData data)
 
         /// <inheritdoc/>
         public Task DragOverAsync(DragData data)
-            => BindIsolatedHandleAsync(async handle =>
+            => BindIsolatedHandleAsync<IElementHandle, ElementHandle>(async handle =>
             {
                 await handle.ScrollIntoViewIfNeededAsync().ConfigureAwait(false);
                 var clickablePoint = await handle.ClickablePointAsync().ConfigureAwait(false);
@@ -637,7 +583,7 @@ public Task DragOverAsync(DragData data)
 
         /// <inheritdoc/>
         public Task DropAsync(DragData data)
-            => BindIsolatedHandleAsync(async handle =>
+            => BindIsolatedHandleAsync<IElementHandle, ElementHandle>(async handle =>
             {
                 await handle.ScrollIntoViewIfNeededAsync().ConfigureAwait(false);
                 var clickablePoint = await handle.ClickablePointAsync().ConfigureAwait(false);
@@ -661,7 +607,7 @@ public async Task DropAsync(IElementHandle target)
 
         /// <inheritdoc/>
         public Task DragAndDropAsync(IElementHandle target, int delay = 0)
-            => BindIsolatedHandleAsync(async handle =>
+            => BindIsolatedHandleAsync<IElementHandle, ElementHandle>(async handle =>
             {
                 if (target == null)
                 {
@@ -684,7 +630,7 @@ await Page.Mouse
 
         /// <inheritdoc/>
         public Task<BoxModelPoint> ClickablePointAsync(Offset? offset = null)
-            => BindIsolatedHandleAsync(async handle =>
+            => BindIsolatedHandleAsync<BoxModelPoint, ElementHandle>(async handle =>
             {
                 var box = await handle.ClickableBoxAsync().ConfigureAwait(false) ?? throw new PuppeteerException("Node is either not clickable or not an Element");
 
@@ -697,105 +643,71 @@ public Task<BoxModelPoint> ClickablePointAsync(Offset? offset = null)
             });
 
         /// <inheritdoc/>
-        public Task<bool> IsVisibleAsync() => BindIsolatedHandleAsync(handle => CheckVisibilityAsync(handle, true));
+        public Task<bool> IsVisibleAsync()
+            => BindIsolatedHandleAsync<bool, ElementHandle>(handle => CheckVisibilityAsync(handle, true));
 
         /// <inheritdoc/>
-        public Task<bool> IsHiddenAsync() => BindIsolatedHandleAsync(handle => CheckVisibilityAsync(handle, false));
+        public Task<bool> IsHiddenAsync()
+            => BindIsolatedHandleAsync<bool, ElementHandle>(handle => CheckVisibilityAsync(handle, false));
 
         /// <inheritdoc/>
         public override Task<IJSHandle> GetPropertyAsync(string propertyName)
-            => BindIsolatedHandleAsync(element => element.Handle.GetPropertyAsync(propertyName));
+            => BindIsolatedHandleAsync<IJSHandle, ElementHandle>(element => element.Handle.GetPropertyAsync(propertyName));
 
         /// <inheritdoc/>
         public override Task<Dictionary<string, IJSHandle>> GetPropertiesAsync()
-            => BindIsolatedHandleAsync(element => element.Handle.GetPropertiesAsync());
+            => BindIsolatedHandleAsync<Dictionary<string, IJSHandle>, ElementHandle>(element => element.Handle.GetPropertiesAsync());
 
         /// <inheritdoc/>
         public override Task<T> JsonValueAsync<T>()
-            => BindIsolatedHandleAsync(element => element.Handle.JsonValueAsync<T>());
+            => BindIsolatedHandleAsync<T, ElementHandle>(element => element.Handle.JsonValueAsync<T>());
 
         /// <inheritdoc/>
-        public Task ScrollIntoViewAsync()
-            => BindIsolatedHandleAsync(async handle =>
-            {
-                await handle.AssertConnectedElementAsync().ConfigureAwait(false);
-                try
-                {
-                    await handle.Client
-                        .SendAsync(
-                            "DOM.scrollIntoViewIfNeeded",
-                            new DomScrollIntoViewIfNeededRequest { ObjectId = Id, })
-                        .ConfigureAwait(false);
-                }
-                catch (Exception ex)
-                {
-                    Logger.LogError(ex, "DOM.scrollIntoViewIfNeeded is not supported");
-                    await handle.EvaluateFunctionAsync(
+        public virtual Task ScrollIntoViewAsync()
+            => BindIsolatedHandleAsync<JToken, ElementHandle>(handle
+                => handle.EvaluateFunctionAsync(
                         @"element => {
                             element.scrollIntoView({
                                 block: 'center',
                                 inline: 'center',
                                 behavior: 'instant',
                             });
-                        }").ConfigureAwait(false);
-                }
-
-                return handle;
-            });
-
-        private async Task<BoundingBox> NonEmptyVisibleBoundingBoxAsync()
+                        }"));
+
+        /// <summary>
+        /// Checks whether the element is still connected to the browser.
+        /// </summary>
+        /// <exception cref="PuppeteerException">The exception if the element is not connected.</exception>
+        /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
+        protected async Task AssertConnectedElementAsync()
         {
-            var box = await BoundingBoxAsync().ConfigureAwait(false) ??
-                      throw new PuppeteerException("Node is either not visible or not an HTMLElement");
-
-            if (box.Width == 0)
-            {
-                throw new PuppeteerException("Node has 0 width.");
-            }
-
-            if (box.Height == 0)
-            {
-                throw new PuppeteerException("Node has 0 height.");
-            }
-
-            return box;
-        }
+            var error = await EvaluateFunctionAsync<string>(@"element => {
+                if (!element.isConnected) {
+                    return 'Node is detached from document';
+                }
 
-        private async Task ScrollIntoViewIfNeededAsync()
-        {
-            if (await IsIntersectingViewportAsync(1).ConfigureAwait(false))
-            {
+                if (element.nodeType !== Node.ELEMENT_NODE) {
+                  return 'Node is not of type HTMLElement';
+                }
                 return;
-            }
-
-            await ScrollIntoViewAsync().ConfigureAwait(false);
-        }
-
-        private Task<bool> CheckVisibilityAsync(IElementHandle handle, bool visibility)
-            => handle.EvaluateFunctionAsync<bool>(
-                @"async (element, PuppeteerUtil, visibility) =>
-                {
-                    return Boolean(PuppeteerUtil.checkVisibility(element, visibility));
-                }",
-                new LazyArg(async context => await context.GetPuppeteerUtilAsync().ConfigureAwait(false)),
-                visibility);
+            }").ConfigureAwait(false);
 
-        private void CheckForFileAccess(string[] files)
-        {
-            foreach (var file in files)
+            if (!string.IsNullOrEmpty(error))
             {
-                try
-                {
-                    File.Open(file, FileMode.Open).Dispose();
-                }
-                catch (Exception ex)
-                {
-                    throw new PuppeteerException($"{files} does not exist or is not readable", ex);
-                }
+                throw new PuppeteerException(error);
             }
         }
 
-        private async Task<T> BindIsolatedHandleAsync<T>(Func<ElementHandle, Task<T>> action)
+        /// <summary>
+        /// Executes a function in the isolated context.
+        /// </summary>
+        /// <param name="action">Function to execute.</param>
+        /// <typeparam name="TResult">Return type.</typeparam>
+        /// <typeparam name="TElementHandle">Element handle type.</typeparam>
+        /// <returns>Task which resolves to the result of the function.</returns>
+        /// <exception cref="ArgumentNullException">Thrown if <paramref name="action"/> is <c>null</c>.</exception>
+        protected async Task<TResult> BindIsolatedHandleAsync<TResult, TElementHandle>(Func<TElementHandle, Task<TResult>> action)
+            where TElementHandle : ElementHandle
         {
             if (action == null)
             {
@@ -804,26 +716,26 @@ private async Task<T> BindIsolatedHandleAsync<T>(Func<ElementHandle, Task<T>> ac
 
             if (Realm == Frame.IsolatedRealm)
             {
-                return await action(this).ConfigureAwait(false);
+                return await action((TElementHandle)this).ConfigureAwait(false);
             }
 
             var adoptedThis = await Frame.IsolatedRealm.AdoptHandleAsync(this).ConfigureAwait(false) as ElementHandle;
-            var result = await action(adoptedThis).ConfigureAwait(false);
+            var result = await action((TElementHandle)adoptedThis).ConfigureAwait(false);
 
             if (result is IJSHandle jsHandleResult)
             {
                 // If the function returns `adoptedThis`, then we return `this` and T is a IJSHandle.
                 if (jsHandleResult == adoptedThis)
                 {
-                    return (T)(object)this;
+                    return (TResult)(object)this;
                 }
 
-                return (T)await Realm.TransferHandleAsync(jsHandleResult).ConfigureAwait(false);
+                return (TResult)await Realm.TransferHandleAsync(jsHandleResult).ConfigureAwait(false);
             }
 
             // If the function returns an array of handlers, transfer them into the current realm.
             // Dynamic arrays using generics can be hard to translate
-            if (typeof(T).IsArray && result is IEnumerable enumerable)
+            if (typeof(TResult).IsArray && result is IEnumerable enumerable)
             {
                 var resultArray = new List<object>();
 
@@ -839,7 +751,7 @@ private async Task<T> BindIsolatedHandleAsync<T>(Func<ElementHandle, Task<T>> ac
                     }
                 }
 
-                var elementType = typeof(T).GetElementType();
+                var elementType = typeof(TResult).GetElementType();
                 if (elementType != null)
                 {
                     var output = Array.CreateInstance(elementType, resultArray.Count);
@@ -850,7 +762,7 @@ private async Task<T> BindIsolatedHandleAsync<T>(Func<ElementHandle, Task<T>> ac
                         output.SetValue(resultArray[i], i);
                     }
 
-                    return (T)(object)output;
+                    return (TResult)(object)output;
                 }
             }
 
@@ -867,6 +779,43 @@ private async Task<T> BindIsolatedHandleAsync<T>(Func<ElementHandle, Task<T>> ac
             return result;
         }
 
+        private async Task<BoundingBox> NonEmptyVisibleBoundingBoxAsync()
+        {
+            var box = await BoundingBoxAsync().ConfigureAwait(false) ??
+                      throw new PuppeteerException("Node is either not visible or not an HTMLElement");
+
+            if (box.Width == 0)
+            {
+                throw new PuppeteerException("Node has 0 width.");
+            }
+
+            if (box.Height == 0)
+            {
+                throw new PuppeteerException("Node has 0 height.");
+            }
+
+            return box;
+        }
+
+        private async Task ScrollIntoViewIfNeededAsync()
+        {
+            if (await IsIntersectingViewportAsync(1).ConfigureAwait(false))
+            {
+                return;
+            }
+
+            await ScrollIntoViewAsync().ConfigureAwait(false);
+        }
+
+        private Task<bool> CheckVisibilityAsync(IElementHandle handle, bool visibility)
+            => handle.EvaluateFunctionAsync<bool>(
+                @"async (element, PuppeteerUtil, visibility) =>
+                {
+                    return Boolean(PuppeteerUtil.checkVisibility(element, visibility));
+                }",
+                new LazyArg(async context => await context.GetPuppeteerUtilAsync().ConfigureAwait(false)),
+                visibility);
+
         private async Task<Point?> GetTopLeftCornerOfFrameAsync()
         {
             var point = default(Point);
@@ -1013,24 +962,5 @@ private void IntersectBoundingBox(BoundingBox box, decimal width, decimal height
                     : Math.Min(height, box.Height + box.Y),
                 0);
         }
-
-        private async Task AssertConnectedElementAsync()
-        {
-            var error = await EvaluateFunctionAsync<string>(@"element => {
-                if (!element.isConnected) {
-                    return 'Node is detached from document';
-                }
-
-                if (element.nodeType !== Node.ELEMENT_NODE) {
-                  return 'Node is not of type HTMLElement';
-                }
-                return;
-            }").ConfigureAwait(false);
-
-            if (!string.IsNullOrEmpty(error))
-            {
-                throw new PuppeteerException(error);
-            }
-        }
     }
 }
diff --git a/lib/PuppeteerSharp/ExecutionContext.cs b/lib/PuppeteerSharp/ExecutionContext.cs
index f74480c8f..dac86bd64 100644
--- a/lib/PuppeteerSharp/ExecutionContext.cs
+++ b/lib/PuppeteerSharp/ExecutionContext.cs
@@ -5,6 +5,7 @@
 using System.Text.RegularExpressions;
 using System.Threading.Tasks;
 using Newtonsoft.Json.Linq;
+using PuppeteerSharp.Cdp;
 using PuppeteerSharp.Helpers;
 using PuppeteerSharp.Messaging;
 
@@ -123,8 +124,8 @@ await InstallGlobalBindingAsync(new Binding(
 
         internal IJSHandle CreateJSHandle(RemoteObject remoteObject)
             => remoteObject.Subtype == RemoteObjectSubtype.Node && Frame != null
-                ? new ElementHandle(World, remoteObject)
-                : new JSHandle(World, remoteObject);
+                ? new CdpElementHandle(World, remoteObject)
+                : new CdpJSHandle(World, remoteObject);
 
         private static string GetExceptionMessage(EvaluateExceptionResponseDetails exceptionDetails)
         {
diff --git a/lib/PuppeteerSharp/Frame.cs b/lib/PuppeteerSharp/Frame.cs
index ed5d4793f..4b5e90030 100644
--- a/lib/PuppeteerSharp/Frame.cs
+++ b/lib/PuppeteerSharp/Frame.cs
@@ -27,7 +27,7 @@ internal Frame(FrameManager frameManager, string frameId, string parentFrameId,
 
             UpdateClient(client);
 
-            FrameSwappedByActivation += (sender, args) =>
+            FrameSwappedByActivation += (_, _) =>
             {
                 // Emulate loading process for swapped frames.
                 OnLoadingStarted();
diff --git a/lib/PuppeteerSharp/JSHandle.cs b/lib/PuppeteerSharp/JSHandle.cs
index c6a08be63..86ac7e05b 100644
--- a/lib/PuppeteerSharp/JSHandle.cs
+++ b/lib/PuppeteerSharp/JSHandle.cs
@@ -1,10 +1,8 @@
 using System;
 using System.Collections.Generic;
 using System.Threading.Tasks;
-using Microsoft.Extensions.Logging;
 using Newtonsoft.Json;
 using Newtonsoft.Json.Linq;
-using PuppeteerSharp.Helpers;
 using PuppeteerSharp.Helpers.Json;
 using PuppeteerSharp.Messaging;
 
@@ -12,23 +10,20 @@ namespace PuppeteerSharp
 {
     /// <inheritdoc/>
     [JsonConverter(typeof(JSHandleMethodConverter))]
-    public class JSHandle : IJSHandle
+    public abstract class JSHandle : IJSHandle
     {
         internal JSHandle(IsolatedWorld world, RemoteObject remoteObject)
         {
             Realm = world;
             RemoteObject = remoteObject;
-            Logger = Client.Connection.LoggerFactory.CreateLogger(GetType());
         }
 
         /// <inheritdoc/>
-        public bool Disposed { get; private set; }
+        public bool Disposed { get; protected set; }
 
         /// <inheritdoc/>
         public RemoteObject RemoteObject { get; }
 
-        internal CDPSession Client => Realm.Environment.Client;
-
         internal Func<Task> DisposeAction { get; set; }
 
         internal IsolatedWorld Realm { get; }
@@ -37,11 +32,6 @@ internal JSHandle(IsolatedWorld world, RemoteObject remoteObject)
 
         internal string Id => RemoteObject.ObjectId;
 
-        /// <summary>
-        /// Logger.
-        /// </summary>
-        protected ILogger Logger { get; }
-
         /// <inheritdoc/>
         public virtual Task<IJSHandle> GetPropertyAsync(string propertyName)
             => EvaluateFunctionHandleAsync(
@@ -83,52 +73,10 @@ public virtual async Task<Dictionary<string, IJSHandle>> GetPropertiesAsync()
         public async Task<object> JsonValueAsync() => await JsonValueAsync<object>().ConfigureAwait(false);
 
         /// <inheritdoc/>
-        public virtual async Task<T> JsonValueAsync<T>()
-        {
-            var objectId = RemoteObject.ObjectId;
-
-            if (objectId == null)
-            {
-                return (T)RemoteObjectHelper.ValueFromRemoteObject<T>(RemoteObject);
-            }
-
-            var value = await EvaluateFunctionAsync<T>("object => object").ConfigureAwait(false);
-
-            return value == null ? throw new PuppeteerException("Could not serialize referenced object") : value;
-        }
+        public abstract Task<T> JsonValueAsync<T>();
 
         /// <inheritdoc/>
-        public async ValueTask DisposeAsync()
-        {
-            if (Disposed)
-            {
-                return;
-            }
-
-            Disposed = true;
-
-            if (DisposeAction != null)
-            {
-                await DisposeAction().ConfigureAwait(false);
-            }
-
-            await RemoteObjectHelper.ReleaseObjectAsync(Client, RemoteObject, Logger).ConfigureAwait(false);
-            GC.SuppressFinalize(this);
-        }
-
-        /// <inheritdoc/>
-        public override string ToString()
-        {
-            if (RemoteObject.ObjectId == null)
-            {
-                return "JSHandle:" + RemoteObjectHelper.ValueFromRemoteObject<object>(RemoteObject, true);
-            }
-
-            var type = RemoteObject.Subtype != RemoteObjectSubtype.Other
-                ? RemoteObject.Subtype.ToString()
-                : RemoteObject.Type.ToString();
-            return "JSHandle@" + type.ToLower(System.Globalization.CultureInfo.CurrentCulture);
-        }
+        public abstract ValueTask DisposeAsync();
 
         /// <inheritdoc/>
         public Task<IJSHandle> EvaluateFunctionHandleAsync(string pageFunction, params object[] args)
diff --git a/lib/PuppeteerSharp/Target.cs b/lib/PuppeteerSharp/Target.cs
index 3aa7ffe3a..5d1b547a0 100644
--- a/lib/PuppeteerSharp/Target.cs
+++ b/lib/PuppeteerSharp/Target.cs
@@ -1,7 +1,6 @@
 using System;
 using System.Diagnostics;
 using System.Threading.Tasks;
-using PuppeteerSharp.Helpers;
 
 namespace PuppeteerSharp
 {