[bun.js] Expose `ImageData` globally

12 files changed, 1237 insertions, 2 deletions

diff --git a/src/javascript/jsc/bindings/ZigGlobalObject.cpp b/src/javascript/jsc/bindings/ZigGlobalObject.cpp
index 5fbf97fc9..ce73975c8 100644
--- a/src/javascript/jsc/bindings/ZigGlobalObject.cpp
+++ b/src/javascript/jsc/bindings/ZigGlobalObject.cpp
@@ -88,6 +88,7 @@
 #include "JSEvent.h"
 #include "JSErrorEvent.h"
 #include "JSFetchHeaders.h"
+#include "JSImageData.h"
 
 #include "Process.h"
 
@@ -396,6 +397,17 @@ JSC_DEFINE_CUSTOM_GETTER(JSFetchHeaders_getter,
         WebCore::JSFetchHeaders::getConstructor(JSC::getVM(lexicalGlobalObject), thisObject));
 }
 
+JSC_DECLARE_CUSTOM_GETTER(JSImageData_getter);
+
+JSC_DEFINE_CUSTOM_GETTER(JSImageData_getter,
+    (JSC::JSGlobalObject * lexicalGlobalObject, JSC::EncodedJSValue thisValue,
+        JSC::PropertyName))
+{
+    Zig::GlobalObject* thisObject = JSC::jsCast<Zig::GlobalObject*>(lexicalGlobalObject);
+    return JSC::JSValue::encode(
+        WebCore::JSImageData::getConstructor(JSC::getVM(lexicalGlobalObject), thisObject));
+}
+
 JSC_DECLARE_CUSTOM_GETTER(JSEventTarget_getter);
 
 JSC_DEFINE_CUSTOM_GETTER(JSEventTarget_getter,
@@ -879,6 +891,9 @@ void GlobalObject::installAPIGlobals(JSClassRef* globals, int count, JSC::VM& vm
     putDirectCustomAccessor(vm, JSC::Identifier::fromString(vm, "ErrorEvent"_s), JSC::CustomGetterSetter::create(vm, JSErrorEvent_getter, nullptr),
         JSC::PropertyAttribute::DontDelete | JSC::PropertyAttribute::ReadOnly);
 
+    putDirectCustomAccessor(vm, JSC::Identifier::fromString(vm, "ImageData"_s), JSC::CustomGetterSetter::create(vm, JSImageData_getter, nullptr),
+        JSC::PropertyAttribute::DontDelete | JSC::PropertyAttribute::ReadOnly);
+
     extraStaticGlobals.releaseBuffer();
 
     this->setRemoteDebuggingEnabled(true);
diff --git a/src/javascript/jsc/bindings/webcore/ArrayBufferView.cpp b/src/javascript/jsc/bindings/webcore/ArrayBufferView.cpp
new file mode 100644
index 000000000..9bb609510
--- /dev/null
+++ b/src/javascript/jsc/bindings/webcore/ArrayBufferView.cpp
@@ -0,0 +1,67 @@
+/*
+ * Copyright (C) 2009-2021 Apple Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "config.h"
+#include "JavaScriptCore/ArrayBufferView.h"
+
+namespace JSC {
+
+ArrayBufferView::ArrayBufferView(
+    RefPtr<ArrayBuffer>&& buffer, size_t byteOffset, size_t byteLength)
+    : m_byteOffset(byteOffset)
+    , m_isDetachable(true)
+    , m_byteLength(byteLength)
+    , m_buffer(WTFMove(buffer))
+{
+    Checked<size_t, CrashOnOverflow> length(byteOffset);
+    length += byteLength;
+    RELEASE_ASSERT_WITH_SECURITY_IMPLICATION(length <= m_buffer->byteLength());
+    if (m_buffer)
+        m_baseAddress = BaseAddress(static_cast<char*>(m_buffer->data()) + m_byteOffset, byteLength);
+}
+
+ArrayBufferView::~ArrayBufferView()
+{
+    if (!m_isDetachable)
+        m_buffer->unpin();
+}
+
+void ArrayBufferView::setDetachable(bool flag)
+{
+    if (flag == m_isDetachable)
+        return;
+
+    m_isDetachable = flag;
+
+    if (!m_buffer)
+        return;
+
+    if (flag)
+        m_buffer->unpin();
+    else
+        m_buffer->pin();
+}
+
+} // namespace JSC
diff --git a/src/javascript/jsc/bindings/webcore/DOMClientIsoSubspaces.h b/src/javascript/jsc/bindings/webcore/DOMClientIsoSubspaces.h
index ad1b6a32b..6d779fccf 100644
--- a/src/javascript/jsc/bindings/webcore/DOMClientIsoSubspaces.h
+++ b/src/javascript/jsc/bindings/webcore/DOMClientIsoSubspaces.h
@@ -541,7 +541,7 @@ public:
     // std::unique_ptr<GCClient::IsoSubspace> m_clientSubspaceForHTMLUnknownElement;
     // std::unique_ptr<GCClient::IsoSubspace> m_clientSubspaceForHTMLVideoElement;
     // std::unique_ptr<GCClient::IsoSubspace> m_clientSubspaceForImageBitmap;
-    // std::unique_ptr<GCClient::IsoSubspace> m_clientSubspaceForImageData;
+    std::unique_ptr<GCClient::IsoSubspace> m_clientSubspaceForImageData;
     // std::unique_ptr<GCClient::IsoSubspace> m_clientSubspaceForMediaController;
     // std::unique_ptr<GCClient::IsoSubspace> m_clientSubspaceForMediaEncryptedEvent;
     // std::unique_ptr<GCClient::IsoSubspace> m_clientSubspaceForMediaError;
diff --git a/src/javascript/jsc/bindings/webcore/DOMIsoSubspaces.h b/src/javascript/jsc/bindings/webcore/DOMIsoSubspaces.h
index 75d91c0a2..3c064cab3 100644
--- a/src/javascript/jsc/bindings/webcore/DOMIsoSubspaces.h
+++ b/src/javascript/jsc/bindings/webcore/DOMIsoSubspaces.h
@@ -532,7 +532,7 @@ public:
     // std::unique_ptr<IsoSubspace> m_subspaceForHTMLUnknownElement;
     // std::unique_ptr<IsoSubspace> m_subspaceForHTMLVideoElement;
     // std::unique_ptr<IsoSubspace> m_subspaceForImageBitmap;
-    // std::unique_ptr<IsoSubspace> m_subspaceForImageData;
+    std::unique_ptr<IsoSubspace> m_subspaceForImageData;
     // std::unique_ptr<IsoSubspace> m_subspaceForMediaController;
     // std::unique_ptr<IsoSubspace> m_subspaceForMediaEncryptedEvent;
     // std::unique_ptr<IsoSubspace> m_subspaceForMediaError;
diff --git a/src/javascript/jsc/bindings/webcore/ImageData.cpp b/src/javascript/jsc/bindings/webcore/ImageData.cpp
new file mode 100644
index 000000000..2e6511bb4
--- /dev/null
+++ b/src/javascript/jsc/bindings/webcore/ImageData.cpp
@@ -0,0 +1,129 @@
+/*
+ * Copyright (C) 2008-2021 Apple Inc. All rights reserved.
+ * Copyright (C) 2014 Adobe Systems Incorporated. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1.  Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ * 2.  Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ * 3.  Neither the name of Apple Inc. ("Apple") nor the names of
+ *     its contributors may be used to endorse or promote products derived
+ *     from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "config.h"
+#include "ImageData.h"
+
+#include "JavaScriptCore/JSGenericTypedArrayViewInlines.h"
+#include "JavaScriptCore/GenericTypedArrayViewInlines.h"
+
+#include "wtf/text/TextStream.h"
+
+namespace WebCore {
+using namespace JSC;
+
+static CheckedUint32 computeDataSize(int width, int height)
+{
+    CheckedUint32 checkedDataSize = 4;
+    checkedDataSize *= static_cast<unsigned>(width);
+    checkedDataSize *= static_cast<unsigned>(height);
+    return checkedDataSize;
+}
+
+// PredefinedColorSpace ImageData::computeColorSpace(std::optional<ImageDataSettings> settings, PredefinedColorSpace defaultColorSpace)
+// {
+//     if (settings && settings->colorSpace)
+//         return *settings->colorSpace;
+//     return defaultColorSpace;
+// }
+
+// Ref<ImageData> ImageData::create(PixelBuffer&& pixelBuffer)
+// {
+//     auto colorSpace = toPredefinedColorSpace(pixelBuffer.format().colorSpace);
+//     return adoptRef(*new ImageData(pixelBuffer.size(), pixelBuffer.takeData(), *colorSpace));
+// }
+
+// RefPtr<ImageData> ImageData::create(std::optional<PixelBuffer>&& pixelBuffer)
+// {
+//     if (!pixelBuffer)
+//         return nullptr;
+//     return create(WTFMove(*pixelBuffer));
+// }
+
+ExceptionOr<Ref<ImageData>> ImageData::create(unsigned int sw, unsigned int sh)
+{
+    if (!sw || !sh)
+        return Exception { IndexSizeError };
+
+    auto dataSize = computeDataSize(static_cast<unsigned>(sw), static_cast<unsigned>(sh));
+    if (dataSize.hasOverflowed())
+        return Exception { RangeError, "Cannot allocate a buffer of this size"_s };
+
+    auto byteArray = Uint8ClampedArray::tryCreateUninitialized(dataSize);
+    if (!byteArray) {
+        // FIXME: Does this need to be a "real" out of memory error with setOutOfMemoryError called on it?
+        return Exception { RangeError, "Out of memory"_s };
+    }
+    byteArray->zeroFill();
+
+    // auto colorSpace = computeColorSpace(settings);
+    return adoptRef(*new ImageData(sw, sh, byteArray.releaseNonNull()));
+}
+
+ExceptionOr<Ref<ImageData>> ImageData::create(Ref<Uint8ClampedArray>&& byteArray, unsigned sw, std::optional<unsigned> sh)
+{
+    unsigned length = byteArray->length();
+    if (!length || length % 4)
+        return Exception { InvalidStateError, "Length is not a non-zero multiple of 4"_s };
+
+    length /= 4;
+    if (!sw || length % sw)
+        return Exception { IndexSizeError, "Length is not a multiple of sw"_s };
+
+    unsigned height = length / sw;
+    if (sh && sh.value() != height)
+        return Exception { IndexSizeError, "sh value is not equal to height"_s };
+
+    int width = sw;
+
+    auto dataSize = computeDataSize(width, height);
+    if (dataSize.hasOverflowed() || dataSize != byteArray->length())
+        return Exception { RangeError };
+
+    // auto colorSpace = computeColorSpace(settings);
+    return adoptRef(*new ImageData(width, height, WTFMove(byteArray)));
+}
+
+ImageData::ImageData(int width, int height, Ref<JSC::Uint8ClampedArray>&& data)
+    : m_data(WTFMove(data))
+// , m_colorSpace(colorSpace)
+{
+    m_width = width;
+    m_height = height;
+}
+
+ImageData::~ImageData() = default;
+
+TextStream& operator<<(TextStream& ts, const ImageData& imageData)
+{
+    // Print out the address of the pixel data array
+    return ts << &imageData.data();
+}
+
+}
diff --git a/src/javascript/jsc/bindings/webcore/ImageData.h b/src/javascript/jsc/bindings/webcore/ImageData.h
new file mode 100644
index 000000000..1f3a7ae0b
--- /dev/null
+++ b/src/javascript/jsc/bindings/webcore/ImageData.h
@@ -0,0 +1,69 @@
+/*
+ * Copyright (C) 2008-2021 Apple Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1.  Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ * 2.  Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ * 3.  Neither the name of Apple Inc. ("Apple") nor the names of
+ *     its contributors may be used to endorse or promote products derived
+ *     from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#pragma once
+
+#include "root.h"
+
+#include "ExceptionOr.h"
+// #include "PixelBuffer.h"
+#include <JavaScriptCore/Forward.h>
+#include <wtf/Forward.h>
+
+namespace WebCore {
+
+class ImageData : public RefCounted<ImageData> {
+public:
+    WEBCORE_EXPORT static ExceptionOr<Ref<ImageData>> create(unsigned sw, unsigned sh);
+    WEBCORE_EXPORT static ExceptionOr<Ref<ImageData>> create(Ref<Uint8ClampedArray>&&, unsigned sw, std::optional<unsigned> sh);
+
+    WEBCORE_EXPORT ~ImageData();
+
+    // static PredefinedColorSpace computeColorSpace(std::optional<ImageDataSettings>, PredefinedColorSpace defaultColorSpace = PredefinedColorSpace::SRGB);
+
+    // const IntSize& size() const { return m_size; }
+
+    int width() const { return m_width; }
+    int height() const { return m_height; }
+    Uint8ClampedArray& data() const { return m_data.get(); }
+    // PredefinedColorSpace colorSpace() const { return m_colorSpace; }
+
+    // PixelBuffer pixelBuffer() const;
+
+private:
+    explicit ImageData(int width, int height, Ref<JSC::Uint8ClampedArray>&&);
+
+    int m_width;
+    int m_height;
+    Ref<JSC::Uint8ClampedArray> m_data;
+    // PredefinedColorSpace m_colorSpace;
+};
+
+WEBCORE_EXPORT TextStream& operator<<(TextStream&, const ImageData&);
+
+} // namespace WebCore
diff --git a/src/javascript/jsc/bindings/webcore/ImageData.idl b/src/javascript/jsc/bindings/webcore/ImageData.idl
new file mode 100644
index 000000000..53713d6a0
--- /dev/null
+++ b/src/javascript/jsc/bindings/webcore/ImageData.idl
@@ -0,0 +1,41 @@
+/*
+ * Copyright (C) 2008-2021 Apple Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1.  Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ * 2.  Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ * 3.  Neither the name of Apple Inc. ("Apple") nor the names of
+ *     its contributors may be used to endorse or promote products derived
+ *     from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+[
+    CustomToJSObject,
+    ExportMacro=WEBCORE_EXPORT,
+    Exposed=(Window,Worker),
+] interface ImageData {
+    constructor(unsigned long sw, unsigned long sh, optional ImageDataSettings settings);
+    constructor(Uint8ClampedArray data, unsigned long sw, optional unsigned long sh, optional ImageDataSettings settings);
+
+    readonly attribute unsigned long width;
+    readonly attribute unsigned long height;
+    readonly attribute Uint8ClampedArray data;
+    [EnabledBySetting=CanvasColorSpaceEnabled] readonly attribute PredefinedColorSpace colorSpace;
+};
diff --git a/src/javascript/jsc/bindings/webcore/JSImageData.cpp b/src/javascript/jsc/bindings/webcore/JSImageData.cpp
new file mode 100644
index 000000000..230558ef6
--- /dev/null
+++ b/src/javascript/jsc/bindings/webcore/JSImageData.cpp
@@ -0,0 +1,359 @@
+/*
+    This file is part of the WebKit open source project.
+    This file has been generated by generate-bindings.pl. DO NOT MODIFY!
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public License
+    along with this library; see the file COPYING.LIB.  If not, write to
+    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+    Boston, MA 02110-1301, USA.
+*/
+
+#include "config.h"
+#include "JSImageData.h"
+
+#include "ActiveDOMObject.h"
+#include "ExtendedDOMClientIsoSubspaces.h"
+#include "ExtendedDOMIsoSubspaces.h"
+#include "JSDOMAttribute.h"
+#include "JSDOMBinding.h"
+#include "JSDOMConstructor.h"
+#include "JSDOMConvertBufferSource.h"
+#include "JSDOMConvertDictionary.h"
+#include "JSDOMConvertEnumeration.h"
+#include "JSDOMConvertInterface.h"
+#include "JSDOMConvertNumbers.h"
+#include "JSDOMExceptionHandling.h"
+#include "JSDOMGlobalObject.h"
+#include "JSDOMGlobalObjectInlines.h"
+#include "JSDOMWrapperCache.h"
+// #include "JSImageDataSettings.h"
+// #include "JSPredefinedColorSpace.h"
+
+#include "ScriptExecutionContext.h"
+#include "WebCoreJSClientData.h"
+#include "JavaScriptCore/FunctionPrototype.h"
+#include "JavaScriptCore/HeapAnalyzer.h"
+#include "JavaScriptCore/JSDestructibleObjectHeapCellType.h"
+#include "JavaScriptCore/SlotVisitorMacros.h"
+#include "JavaScriptCore/SubspaceInlines.h"
+#include <wtf/GetPtr.h>
+#include <wtf/PointerPreparations.h>
+#include <wtf/URL.h>
+
+#include "JavaScriptCore/JSArrayBufferViewInlines.h"
+#include "JavaScriptCore/JSGenericTypedArrayViewInlines.h"
+#include "JavaScriptCore/ArrayBufferView.h"
+#include "JavaScriptCore/JSCInlines.h"
+#include "JSImageData.h"
+
+namespace WebCore {
+using namespace JSC;
+
+// Attributes
+
+static JSC_DECLARE_CUSTOM_GETTER(jsImageDataConstructor);
+static JSC_DECLARE_CUSTOM_GETTER(jsImageData_width);
+static JSC_DECLARE_CUSTOM_GETTER(jsImageData_height);
+static JSC_DECLARE_CUSTOM_GETTER(jsImageData_data);
+// static JSC_DECLARE_CUSTOM_GETTER(jsImageData_colorSpace);
+
+class JSImageDataPrototype final : public JSC::JSNonFinalObject {
+public:
+    using Base = JSC::JSNonFinalObject;
+    static JSImageDataPrototype* create(JSC::VM& vm, JSDOMGlobalObject* globalObject, JSC::Structure* structure)
+    {
+        JSImageDataPrototype* ptr = new (NotNull, JSC::allocateCell<JSImageDataPrototype>(vm)) JSImageDataPrototype(vm, globalObject, structure);
+        ptr->finishCreation(vm);
+        return ptr;
+    }
+
+    DECLARE_INFO;
+    template<typename CellType, JSC::SubspaceAccess>
+    static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+    {
+        STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSImageDataPrototype, Base);
+        return &vm.plainObjectSpace();
+    }
+    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+    {
+        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());
+    }
+
+private:
+    JSImageDataPrototype(JSC::VM& vm, JSC::JSGlobalObject*, JSC::Structure* structure)
+        : JSC::JSNonFinalObject(vm, structure)
+    {
+    }
+
+    void finishCreation(JSC::VM&);
+};
+STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSImageDataPrototype, JSImageDataPrototype::Base);
+
+using JSImageDataDOMConstructor = JSDOMConstructor<JSImageData>;
+
+static inline EncodedJSValue constructJSImageData1(JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame)
+{
+    VM& vm = lexicalGlobalObject->vm();
+    auto throwScope = DECLARE_THROW_SCOPE(vm);
+    auto* castedThis = jsCast<JSImageDataDOMConstructor*>(callFrame->jsCallee());
+    ASSERT(castedThis);
+    EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
+    auto sw = convert<IDLUnsignedLong>(*lexicalGlobalObject, argument0.value());
+    RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
+    EnsureStillAliveScope argument1 = callFrame->uncheckedArgument(1);
+    auto sh = convert<IDLUnsignedLong>(*lexicalGlobalObject, argument1.value());
+    RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
+    // auto settings = convert<IDLDictionary<ImageDataSettings>>(*lexicalGlobalObject, argument2.value());
+    // RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
+    auto object = ImageData::create(WTFMove(sw), WTFMove(sh));
+    if constexpr (IsExceptionOr<decltype(object)>)
+        RETURN_IF_EXCEPTION(throwScope, {});
+    static_assert(TypeOrExceptionOrUnderlyingType<decltype(object)>::isRef);
+    auto jsValue = toJSNewlyCreated<IDLInterface<ImageData>>(*lexicalGlobalObject, *castedThis->globalObject(), throwScope, WTFMove(object));
+    if constexpr (IsExceptionOr<decltype(object)>)
+        RETURN_IF_EXCEPTION(throwScope, {});
+    setSubclassStructureIfNeeded<ImageData>(lexicalGlobalObject, callFrame, asObject(jsValue));
+    RETURN_IF_EXCEPTION(throwScope, {});
+    return JSValue::encode(jsValue);
+}
+
+static inline EncodedJSValue constructJSImageData2(JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame)
+{
+    VM& vm = lexicalGlobalObject->vm();
+    auto throwScope = DECLARE_THROW_SCOPE(vm);
+    auto* castedThis = jsCast<JSImageDataDOMConstructor*>(callFrame->jsCallee());
+    ASSERT(castedThis);
+    EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
+    auto data = convert<IDLUint8ClampedArray>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "data", "ImageData", nullptr, "Uint8ClampedArray"); });
+    RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
+    EnsureStillAliveScope argument1 = callFrame->uncheckedArgument(1);
+    auto sw = convert<IDLUnsignedLong>(*lexicalGlobalObject, argument1.value());
+    RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
+    EnsureStillAliveScope argument2 = callFrame->argument(2);
+    auto sh = argument2.value().isUndefined() ? std::optional<Converter<IDLUnsignedLong>::ReturnType>() : std::optional<Converter<IDLUnsignedLong>::ReturnType>(convert<IDLUnsignedLong>(*lexicalGlobalObject, argument2.value()));
+    RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
+    auto object = ImageData::create(data.releaseNonNull(), WTFMove(sw), WTFMove(sh));
+    if constexpr (IsExceptionOr<decltype(object)>)
+        RETURN_IF_EXCEPTION(throwScope, {});
+    static_assert(TypeOrExceptionOrUnderlyingType<decltype(object)>::isRef);
+    auto jsValue = toJSNewlyCreated<IDLInterface<ImageData>>(*lexicalGlobalObject, *castedThis->globalObject(), throwScope, WTFMove(object));
+    if constexpr (IsExceptionOr<decltype(object)>)
+        RETURN_IF_EXCEPTION(throwScope, {});
+    setSubclassStructureIfNeeded<ImageData>(lexicalGlobalObject, callFrame, asObject(jsValue));
+    RETURN_IF_EXCEPTION(throwScope, {});
+    return JSValue::encode(jsValue);
+}
+
+template<> EncodedJSValue JSC_HOST_CALL_ATTRIBUTES JSImageDataDOMConstructor::construct(JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame)
+{
+    VM& vm = lexicalGlobalObject->vm();
+    auto throwScope = DECLARE_THROW_SCOPE(vm);
+    UNUSED_PARAM(throwScope);
+    size_t argsCount = std::min<size_t>(4, callFrame->argumentCount());
+    if (argsCount == 2) {
+        JSValue distinguishingArg = callFrame->uncheckedArgument(0);
+        if (distinguishingArg.isObject() && asObject(distinguishingArg)->inherits<JSUint8ClampedArray>(vm))
+            RELEASE_AND_RETURN(throwScope, (constructJSImageData2(lexicalGlobalObject, callFrame)));
+        if (distinguishingArg.isNumber())
+            RELEASE_AND_RETURN(throwScope, (constructJSImageData1(lexicalGlobalObject, callFrame)));
+        RELEASE_AND_RETURN(throwScope, (constructJSImageData1(lexicalGlobalObject, callFrame)));
+    }
+    if (argsCount == 3) {
+        JSValue distinguishingArg = callFrame->uncheckedArgument(0);
+        if (distinguishingArg.isObject() && asObject(distinguishingArg)->inherits<JSUint8ClampedArray>(vm))
+            RELEASE_AND_RETURN(throwScope, (constructJSImageData2(lexicalGlobalObject, callFrame)));
+        if (distinguishingArg.isNumber())
+            RELEASE_AND_RETURN(throwScope, (constructJSImageData1(lexicalGlobalObject, callFrame)));
+        RELEASE_AND_RETURN(throwScope, (constructJSImageData1(lexicalGlobalObject, callFrame)));
+    }
+    if (argsCount == 4) {
+        RELEASE_AND_RETURN(throwScope, (constructJSImageData2(lexicalGlobalObject, callFrame)));
+    }
+    return argsCount < 2 ? throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject)) : throwVMTypeError(lexicalGlobalObject, throwScope);
+}
+JSC_ANNOTATE_HOST_FUNCTION(JSImageDataConstructorConstruct, JSImageDataDOMConstructor::construct);
+
+template<> const ClassInfo JSImageDataDOMConstructor::s_info = { "ImageData"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSImageDataDOMConstructor) };
+
+template<> JSValue JSImageDataDOMConstructor::prototypeForStructure(JSC::VM& vm, const JSDOMGlobalObject& globalObject)
+{
+    UNUSED_PARAM(vm);
+    return globalObject.functionPrototype();
+}
+
+template<> void JSImageDataDOMConstructor::initializeProperties(VM& vm, JSDOMGlobalObject& globalObject)
+{
+    putDirect(vm, vm.propertyNames->length, jsNumber(2), JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::DontEnum);
+    JSString* nameString = jsNontrivialString(vm, "ImageData"_s);
+    m_originalName.set(vm, this, nameString);
+    putDirect(vm, vm.propertyNames->name, nameString, JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::DontEnum);
+    putDirect(vm, vm.propertyNames->prototype, JSImageData::prototype(vm, globalObject), JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::DontDelete);
+}
+
+/* Hash table for prototype */
+
+static const HashTableValue JSImageDataPrototypeTableValues[] = {
+    { "constructor", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t) static_cast<PropertySlot::GetValueFunc>(jsImageDataConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) } },
+    { "width", static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute), NoIntrinsic, { (intptr_t) static_cast<PropertySlot::GetValueFunc>(jsImageData_width), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) } },
+    { "height", static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute), NoIntrinsic, { (intptr_t) static_cast<PropertySlot::GetValueFunc>(jsImageData_height), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) } },
+    { "data", static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute), NoIntrinsic, { (intptr_t) static_cast<PropertySlot::GetValueFunc>(jsImageData_data), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) } },
+    // { "colorSpace", static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute), NoIntrinsic, { (intptr_t) static_cast<PropertySlot::GetValueFunc>(jsImageData_colorSpace), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) } },
+};
+
+const ClassInfo JSImageDataPrototype::s_info = { "ImageData"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSImageDataPrototype) };
+
+void JSImageDataPrototype::finishCreation(VM& vm)
+{
+    Base::finishCreation(vm);
+    reifyStaticProperties(vm, JSImageData::info(), JSImageDataPrototypeTableValues, *this);
+    JSC_TO_STRING_TAG_WITHOUT_TRANSITION();
+}
+
+const ClassInfo JSImageData::s_info = { "ImageData"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSImageData) };
+
+JSImageData::JSImageData(Structure* structure, JSDOMGlobalObject& globalObject, Ref<ImageData>&& impl)
+    : JSDOMWrapper<ImageData>(structure, globalObject, WTFMove(impl))
+{
+}
+
+void JSImageData::finishCreation(VM& vm)
+{
+    Base::finishCreation(vm);
+    ASSERT(inherits(vm, info()));
+
+    // static_assert(!std::is_base_of<ActiveDOMObject, ImageData>::value, "Interface is not marked as [ActiveDOMObject] even though implementation class subclasses ActiveDOMObject.");
+}
+
+JSObject* JSImageData::createPrototype(VM& vm, JSDOMGlobalObject& globalObject)
+{
+    return JSImageDataPrototype::create(vm, &globalObject, JSImageDataPrototype::createStructure(vm, &globalObject, globalObject.objectPrototype()));
+}
+
+JSObject* JSImageData::prototype(VM& vm, JSDOMGlobalObject& globalObject)
+{
+    return getDOMPrototype<JSImageData>(vm, globalObject);
+}
+
+JSValue JSImageData::getConstructor(VM& vm, const JSGlobalObject* globalObject)
+{
+    return getDOMConstructor<JSImageDataDOMConstructor, DOMConstructorID::ImageData>(vm, *jsCast<const JSDOMGlobalObject*>(globalObject));
+}
+
+void JSImageData::destroy(JSC::JSCell* cell)
+{
+    JSImageData* thisObject = static_cast<JSImageData*>(cell);
+    thisObject->JSImageData::~JSImageData();
+}
+
+JSC_DEFINE_CUSTOM_GETTER(jsImageDataConstructor, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName))
+{
+    VM& vm = JSC::getVM(lexicalGlobalObject);
+    auto throwScope = DECLARE_THROW_SCOPE(vm);
+    auto* prototype = jsDynamicCast<JSImageDataPrototype*>(vm, JSValue::decode(thisValue));
+    if (UNLIKELY(!prototype))
+        return throwVMTypeError(lexicalGlobalObject, throwScope);
+    return JSValue::encode(JSImageData::getConstructor(JSC::getVM(lexicalGlobalObject), prototype->globalObject()));
+}
+
+static inline JSValue jsImageData_widthGetter(JSGlobalObject& lexicalGlobalObject, JSImageData& thisObject)
+{
+    auto& vm = JSC::getVM(&lexicalGlobalObject);
+    auto throwScope = DECLARE_THROW_SCOPE(vm);
+    auto& impl = thisObject.wrapped();
+    RELEASE_AND_RETURN(throwScope, (toJS<IDLUnsignedLong>(lexicalGlobalObject, throwScope, impl.width())));
+}
+
+JSC_DEFINE_CUSTOM_GETTER(jsImageData_width, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
+{
+    return IDLAttribute<JSImageData>::get<jsImageData_widthGetter, CastedThisErrorBehavior::Assert>(*lexicalGlobalObject, thisValue, attributeName);
+}
+
+static inline JSValue jsImageData_heightGetter(JSGlobalObject& lexicalGlobalObject, JSImageData& thisObject)
+{
+    auto& vm = JSC::getVM(&lexicalGlobalObject);
+    auto throwScope = DECLARE_THROW_SCOPE(vm);
+    auto& impl = thisObject.wrapped();
+    RELEASE_AND_RETURN(throwScope, (toJS<IDLUnsignedLong>(lexicalGlobalObject, throwScope, impl.height())));
+}
+
+JSC_DEFINE_CUSTOM_GETTER(jsImageData_height, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
+{
+    return IDLAttribute<JSImageData>::get<jsImageData_heightGetter, CastedThisErrorBehavior::Assert>(*lexicalGlobalObject, thisValue, attributeName);
+}
+
+static inline JSValue jsImageData_dataGetter(JSGlobalObject& lexicalGlobalObject, JSImageData& thisObject)
+{
+    auto& vm = JSC::getVM(&lexicalGlobalObject);
+    auto throwScope = DECLARE_THROW_SCOPE(vm);
+    auto& impl = thisObject.wrapped();
+    RELEASE_AND_RETURN(throwScope, (toJS<IDLUint8ClampedArray>(lexicalGlobalObject, *thisObject.globalObject(), throwScope, impl.data())));
+}
+
+JSC_DEFINE_CUSTOM_GETTER(jsImageData_data, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
+{
+    return IDLAttribute<JSImageData>::get<jsImageData_dataGetter, CastedThisErrorBehavior::Assert>(*lexicalGlobalObject, thisValue, attributeName);
+}
+
+// static inline JSValue jsImageData_colorSpaceGetter(JSGlobalObject& lexicalGlobalObject, JSImageData& thisObject)
+// {
+//     return JSC::JSValue(JSC::jsString(lexicalGlobalObject.vm(), "srgb"_s));
+// }
+
+// JSC_DEFINE_CUSTOM_GETTER(jsImageData_colorSpace, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
+// {
+//     return JSC::JSValue::encode(
+//         jsImageData_colorSpaceGetter(*lexicalGlobalObject, *jsCast<JSImageData*>(JSValue::decode(thisValue))));
+// }
+
+JSC::GCClient::IsoSubspace* JSImageData::subspaceForImpl(JSC::VM& vm)
+{
+    return WebCore::subspaceForImpl<JSImageData, UseCustomHeapCellType::No>(
+        vm,
+        [](auto& spaces) { return spaces.m_clientSubspaceForImageData.get(); },
+        [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForImageData = WTFMove(space); },
+        [](auto& spaces) { return spaces.m_subspaceForImageData.get(); },
+        [](auto& spaces, auto&& space) { spaces.m_subspaceForImageData = WTFMove(space); });
+}
+
+void JSImageData::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)
+{
+    auto* thisObject = jsCast<JSImageData*>(cell);
+    analyzer.setWrappedObjectForCell(cell, &thisObject->wrapped());
+    if (thisObject->scriptExecutionContext())
+        analyzer.setLabelForCell(cell, "url " + thisObject->scriptExecutionContext()->url().string());
+    Base::analyzeHeap(cell, analyzer);
+}
+
+bool JSImageDataOwner::isReachableFromOpaqueRoots(JSC::Handle<JSC::Unknown> handle, void*, AbstractSlotVisitor& visitor, const char** reason)
+{
+    UNUSED_PARAM(handle);
+    UNUSED_PARAM(visitor);
+    UNUSED_PARAM(reason);
+    return false;
+}
+
+void JSImageDataOwner::finalize(JSC::Handle<JSC::Unknown> handle, void* context)
+{
+    auto* jsImageData = static_cast<JSImageData*>(handle.slot()->asCell());
+    auto& world = *static_cast<DOMWrapperWorld*>(context);
+    uncacheWrapper(world, &jsImageData->wrapped(), jsImageData);
+}
+
+ImageData* JSImageData::toWrapped(JSC::VM& vm, JSC::JSValue value)
+{
+    if (auto* wrapper = jsDynamicCast<JSImageData*>(vm, value))
+        return &wrapper->wrapped();
+    return nullptr;
+}
+
+}
diff --git a/src/javascript/jsc/bindings/webcore/JSImageData.dep b/src/javascript/jsc/bindings/webcore/JSImageData.dep
new file mode 100644
index 000000000..5c5941ed3
--- /dev/null
+++ b/src/javascript/jsc/bindings/webcore/JSImageData.dep
@@ -0,0 +1 @@
+JSImageData.h : 
diff --git a/src/javascript/jsc/bindings/webcore/JSImageData.h b/src/javascript/jsc/bindings/webcore/JSImageData.h
new file mode 100644
index 000000000..29e7cc6ed
--- /dev/null
+++ b/src/javascript/jsc/bindings/webcore/JSImageData.h
@@ -0,0 +1,94 @@
+/*
+    This file is part of the WebKit open source project.
+    This file has been generated by generate-bindings.pl. DO NOT MODIFY!
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public License
+    along with this library; see the file COPYING.LIB.  If not, write to
+    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+    Boston, MA 02110-1301, USA.
+*/
+
+#pragma once
+
+#include "ImageData.h"
+#include "JSDOMWrapper.h"
+#include <wtf/NeverDestroyed.h>
+
+namespace WebCore {
+
+class WEBCORE_EXPORT JSImageData : public JSDOMWrapper<ImageData> {
+public:
+    using Base = JSDOMWrapper<ImageData>;
+    static JSImageData* create(JSC::Structure* structure, JSDOMGlobalObject* globalObject, Ref<ImageData>&& impl)
+    {
+        JSImageData* ptr = new (NotNull, JSC::allocateCell<JSImageData>(globalObject->vm())) JSImageData(structure, *globalObject, WTFMove(impl));
+        ptr->finishCreation(globalObject->vm());
+        return ptr;
+    }
+
+    static JSC::JSObject* createPrototype(JSC::VM&, JSDOMGlobalObject&);
+    static JSC::JSObject* prototype(JSC::VM&, JSDOMGlobalObject&);
+    static ImageData* toWrapped(JSC::VM&, JSC::JSValue);
+    static void destroy(JSC::JSCell*);
+
+    DECLARE_INFO;
+
+    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+    {
+        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info(), JSC::NonArray);
+    }
+
+    static JSC::JSValue getConstructor(JSC::VM&, const JSC::JSGlobalObject*);
+    template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+    {
+        if constexpr (mode == JSC::SubspaceAccess::Concurrently)
+            return nullptr;
+        return subspaceForImpl(vm);
+    }
+    static JSC::GCClient::IsoSubspace* subspaceForImpl(JSC::VM& vm);
+    static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);
+
+protected:
+    JSImageData(JSC::Structure*, JSDOMGlobalObject&, Ref<ImageData>&&);
+
+    void finishCreation(JSC::VM&);
+};
+
+class WEBCORE_EXPORT JSImageDataOwner final : public JSC::WeakHandleOwner {
+public:
+    bool isReachableFromOpaqueRoots(JSC::Handle<JSC::Unknown>, void* context, JSC::AbstractSlotVisitor&, const char**) final;
+    void finalize(JSC::Handle<JSC::Unknown>, void* context) final;
+};
+
+inline JSC::WeakHandleOwner* wrapperOwner(DOMWrapperWorld&, ImageData*)
+{
+    static NeverDestroyed<JSImageDataOwner> owner;
+    return &owner.get();
+}
+
+inline void* wrapperKey(ImageData* wrappableObject)
+{
+    return wrappableObject;
+}
+
+WEBCORE_EXPORT JSC::JSValue toJS(JSC::JSGlobalObject*, JSDOMGlobalObject*, ImageData&);
+inline JSC::JSValue toJS(JSC::JSGlobalObject* lexicalGlobalObject, JSDOMGlobalObject* globalObject, ImageData* impl) { return impl ? toJS(lexicalGlobalObject, globalObject, *impl) : JSC::jsNull(); }
+JSC::JSValue toJSNewlyCreated(JSC::JSGlobalObject*, JSDOMGlobalObject*, Ref<ImageData>&&);
+inline JSC::JSValue toJSNewlyCreated(JSC::JSGlobalObject* lexicalGlobalObject, JSDOMGlobalObject* globalObject, RefPtr<ImageData>&& impl) { return impl ? toJSNewlyCreated(lexicalGlobalObject, globalObject, impl.releaseNonNull()) : JSC::jsNull(); }
+
+template<> struct JSDOMWrapperConverterTraits<ImageData> {
+    using WrapperClass = JSImageData;
+    using ToWrappedReturnType = ImageData*;
+};
+
+} // namespace WebCore
diff --git a/src/javascript/jsc/bindings/webcore/JSImageDataCustom.cpp b/src/javascript/jsc/bindings/webcore/JSImageDataCustom.cpp
new file mode 100644
index 000000000..43c9871d6
--- /dev/null
+++ b/src/javascript/jsc/bindings/webcore/JSImageDataCustom.cpp
@@ -0,0 +1,59 @@
+/*
+ * Copyright (C) 2008-2019 Apple Inc. All Rights Reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
+ */
+
+#include "config.h"
+#include "JSImageData.h"
+
+#include "JSDOMConvert.h"
+#include "JSDOMWrapperCache.h"
+#include <JavaScriptCore/HeapInlines.h>
+#include <JavaScriptCore/IdentifierInlines.h>
+#include <JavaScriptCore/JSObjectInlines.h>
+#include <wtf/StdLibExtras.h>
+#include <wtf/text/WTFString.h>
+
+namespace WebCore {
+using namespace JSC;
+
+JSValue toJSNewlyCreated(JSGlobalObject* lexicalGlobalObject, JSDOMGlobalObject* globalObject, Ref<ImageData>&& imageData)
+{
+    VM& vm = lexicalGlobalObject->vm();
+    auto& data = imageData->data();
+    auto* wrapper = createWrapper<ImageData>(globalObject, WTFMove(imageData));
+    Identifier dataName = Identifier::fromString(vm, "data");
+    wrapper->putDirect(vm, dataName, toJS(lexicalGlobalObject, globalObject, data), PropertyAttribute::DontDelete | PropertyAttribute::ReadOnly);
+    // FIXME: Adopt reportExtraMemoryVisited, and switch to reportExtraMemoryAllocated.
+    // https://bugs.webkit.org/show_bug.cgi?id=142595
+    vm.heap.deprecatedReportExtraMemory(data.length());
+    
+    return wrapper;
+}
+
+JSValue toJS(JSGlobalObject* lexicalGlobalObject, JSDOMGlobalObject* globalObject, ImageData& imageData)
+{
+    return wrap(lexicalGlobalObject, globalObject, imageData);
+}
+
+}
diff --git a/types/bun/bun.d.ts b/types/bun/bun.d.ts
index 3fc0d3b7c..bb7872d59 100644
--- a/types/bun/bun.d.ts
+++ b/types/bun/bun.d.ts
@@ -928,6 +928,380 @@ declare global {
     name: never;
   }
 
+  type CanvasImageSource = Blob | ImageData | TypedArray;
+
+  // -----
+  // canvas
+  interface HTMLCanvasElement {
+    transferControlToOffscreen(): OffscreenCanvas;
+  }
+
+  interface CanvasDrawImage {
+    drawImage(image: CanvasImageSource, dx: number, dy: number): void;
+    drawImage(
+      image: CanvasImageSource,
+      dx: number,
+      dy: number,
+      dw: number,
+      dh: number
+    ): void;
+    drawImage(
+      image: CanvasImageSource,
+      sx: number,
+      sy: number,
+      sw: number,
+      sh: number,
+      dx: number,
+      dy: number,
+      dw: number,
+      dh: number
+    ): void;
+  }
+
+  interface CanvasDrawPath {
+    beginPath(): void;
+    clip(fillRule?: CanvasFillRule): void;
+    clip(path: Path2D, fillRule?: CanvasFillRule): void;
+    fill(fillRule?: CanvasFillRule): void;
+    fill(path: Path2D, fillRule?: CanvasFillRule): void;
+    isPointInPath(x: number, y: number, fillRule?: CanvasFillRule): boolean;
+    isPointInPath(
+      path: Path2D,
+      x: number,
+      y: number,
+      fillRule?: CanvasFillRule
+    ): boolean;
+    isPointInStroke(x: number, y: number): boolean;
+    isPointInStroke(path: Path2D, x: number, y: number): boolean;
+    stroke(): void;
+    stroke(path: Path2D): void;
+  }
+
+  interface CanvasFillStrokeStyles {
+    fillStyle: string | CanvasGradient | CanvasPattern;
+    strokeStyle: string | CanvasGradient | CanvasPattern;
+    createConicGradient(
+      startAngle: number,
+      x: number,
+      y: number
+    ): CanvasGradient;
+    createLinearGradient(
+      x0: number,
+      y0: number,
+      x1: number,
+      y1: number
+    ): CanvasGradient;
+    createPattern(
+      image: CanvasImageSource,
+      repetition: string | null
+    ): CanvasPattern | null;
+    createRadialGradient(
+      x0: number,
+      y0: number,
+      r0: number,
+      x1: number,
+      y1: number,
+      r1: number
+    ): CanvasGradient;
+  }
+
+  interface CanvasFilters {
+    filter: string;
+  }
+
+  /** An opaque object describing a gradient. It is returned by the methods CanvasRenderingContext2D.createLinearGradient() or CanvasRenderingContext2D.createRadialGradient(). */
+  interface CanvasGradient {
+    /**
+     * Adds a color stop with the given color to the gradient at the given offset. 0.0 is the offset at one end of the gradient, 1.0 is the offset at the other end.
+     *
+     * Throws an "IndexSizeError" DOMException if the offset is out of range. Throws a "SyntaxError" DOMException if the color cannot be parsed.
+     */
+    addColorStop(offset: number, color: string): void;
+  }
+
+  declare var CanvasGradient: {
+    prototype: CanvasGradient;
+    new (): CanvasGradient;
+  };
+
+  /** The underlying pixel data of an area of a <canvas> element. It is created using the ImageData() constructor or creator methods on the CanvasRenderingContext2D object associated with a canvas: createImageData() and getImageData(). It can also be used to set a part of the canvas by using putImageData(). */
+  interface ImageData {
+    /** Returns the one-dimensional array containing the data in RGBA order, as integers in the range 0 to 255. */
+    readonly data: Uint8ClampedArray;
+    /** Returns the actual dimensions of the data in the ImageData object, in pixels. */
+    readonly height: number;
+    /** Returns the actual dimensions of the data in the ImageData object, in pixels. */
+    readonly width: number;
+  }
+
+  declare var ImageData: {
+    prototype: ImageData;
+    new (sw: number, sh: number, settings?: ImageDataSettings): ImageData;
+    new (
+      data: Uint8ClampedArray,
+      sw: number,
+      sh?: number,
+      settings?: ImageDataSettings
+    ): ImageData;
+  };
+
+  interface CanvasImageData {
+    createImageData(
+      sw: number,
+      sh: number,
+      settings?: ImageDataSettings
+    ): ImageData;
+    createImageData(imagedata: ImageData): ImageData;
+    getImageData(
+      sx: number,
+      sy: number,
+      sw: number,
+      sh: number,
+      settings?: ImageDataSettings
+    ): ImageData;
+    putImageData(imagedata: ImageData, dx: number, dy: number): void;
+    putImageData(
+      imagedata: ImageData,
+      dx: number,
+      dy: number,
+      dirtyX: number,
+      dirtyY: number,
+      dirtyWidth: number,
+      dirtyHeight: number
+    ): void;
+  }
+
+  interface CanvasImageSmoothing {
+    imageSmoothingEnabled: boolean;
+    imageSmoothingQuality: ImageSmoothingQuality;
+  }
+
+  interface CanvasPath {
+    arc(
+      x: number,
+      y: number,
+      radius: number,
+      startAngle: number,
+      endAngle: number,
+      counterclockwise?: boolean
+    ): void;
+    arcTo(x1: number, y1: number, x2: number, y2: number, radius: number): void;
+    bezierCurveTo(
+      cp1x: number,
+      cp1y: number,
+      cp2x: number,
+      cp2y: number,
+      x: number,
+      y: number
+    ): void;
+    closePath(): void;
+    ellipse(
+      x: number,
+      y: number,
+      radiusX: number,
+      radiusY: number,
+      rotation: number,
+      startAngle: number,
+      endAngle: number,
+      counterclockwise?: boolean
+    ): void;
+    lineTo(x: number, y: number): void;
+    moveTo(x: number, y: number): void;
+    quadraticCurveTo(cpx: number, cpy: number, x: number, y: number): void;
+    rect(x: number, y: number, w: number, h: number): void;
+  }
+
+  interface CanvasPathDrawingStyles {
+    lineCap: CanvasLineCap;
+    lineDashOffset: number;
+    lineJoin: CanvasLineJoin;
+    lineWidth: number;
+    miterLimit: number;
+    getLineDash(): number[];
+    setLineDash(segments: number[]): void;
+  }
+
+  /** An opaque object describing a pattern, based on an image, a canvas, or a video, created by the CanvasRenderingContext2D.createPattern() method. */
+  interface CanvasPattern {
+    /** Sets the transformation matrix that will be used when rendering the pattern during a fill or stroke painting operation. */
+    setTransform(transform?: DOMMatrix2DInit): void;
+  }
+
+  declare var CanvasPattern: {
+    prototype: CanvasPattern;
+    new (): CanvasPattern;
+  };
+
+  interface CanvasRect {
+    clearRect(x: number, y: number, w: number, h: number): void;
+    fillRect(x: number, y: number, w: number, h: number): void;
+    strokeRect(x: number, y: number, w: number, h: number): void;
+  }
+
+  /** The CanvasRenderingContext2D interface, part of the Canvas API, provides the 2D rendering context for the drawing surface of a <canvas> element. It is used for drawing shapes, text, images, and other objects. */
+  interface CanvasRenderingContext2D
+    extends CanvasCompositing,
+      CanvasDrawImage,
+      CanvasDrawPath,
+      CanvasFillStrokeStyles,
+      CanvasFilters,
+      CanvasImageData,
+      CanvasImageSmoothing,
+      CanvasPath,
+      CanvasPathDrawingStyles,
+      CanvasRect,
+      CanvasShadowStyles,
+      CanvasState,
+      CanvasText,
+      CanvasTextDrawingStyles,
+      CanvasTransform,
+      CanvasUserInterface {
+    readonly canvas: HTMLCanvasElement;
+    getContextAttributes(): CanvasRenderingContext2DSettings;
+  }
+
+  interface CanvasShadowStyles {
+    shadowBlur: number;
+    shadowColor: string;
+    shadowOffsetX: number;
+    shadowOffsetY: number;
+  }
+
+  interface CanvasState {
+    restore(): void;
+    save(): void;
+  }
+
+  interface CanvasText {
+    fillText(text: string, x: number, y: number, maxWidth?: number): void;
+    measureText(text: string): TextMetrics;
+    strokeText(text: string, x: number, y: number, maxWidth?: number): void;
+  }
+
+  interface CanvasTextDrawingStyles {
+    direction: CanvasDirection;
+    font: string;
+    textAlign: CanvasTextAlign;
+    textBaseline: CanvasTextBaseline;
+  }
+
+  interface CanvasTransform {
+    getTransform(): DOMMatrix;
+    resetTransform(): void;
+    rotate(angle: number): void;
+    scale(x: number, y: number): void;
+    setTransform(
+      a: number,
+      b: number,
+      c: number,
+      d: number,
+      e: number,
+      f: number
+    ): void;
+    setTransform(transform?: DOMMatrix2DInit): void;
+    transform(
+      a: number,
+      b: number,
+      c: number,
+      d: number,
+      e: number,
+      f: number
+    ): void;
+    translate(x: number, y: number): void;
+  }
+
+  interface CanvasUserInterface {
+    drawFocusIfNeeded(element: Element): void;
+    drawFocusIfNeeded(path: Path2D, element: Element): void;
+  }
+
+  // https://html.spec.whatwg.org/multipage/canvas.html#offscreencanvasrenderingcontext2d
+  interface OffscreenCanvasRenderingContext2D
+    extends CanvasState,
+      CanvasTransform,
+      CanvasCompositing,
+      CanvasImageSmoothing,
+      CanvasFillStrokeStyles,
+      CanvasShadowStyles,
+      CanvasFilters,
+      CanvasRect,
+      CanvasDrawPath,
+      CanvasText,
+      CanvasDrawImage,
+      CanvasImageData,
+      CanvasPathDrawingStyles,
+      CanvasTextDrawingStyles,
+      CanvasPath {
+    readonly canvas: OffscreenCanvas;
+  }
+
+  declare var OffscreenCanvasRenderingContext2D: {
+    prototype: OffscreenCanvasRenderingContext2D;
+    new (): OffscreenCanvasRenderingContext2D;
+  };
+
+  // https://html.spec.whatwg.org/multipage/canvas.html#the-offscreencanvas-interface
+  // Possible contextId values are defined by the enum OffscreenRenderingContextId { "2d", "bitmaprenderer", "webgl", "webgl2" }
+  // See also description: https://developer.mozilla.org/en-US/docs/Web/API/OffscreenCanvas/getContext
+  class OffscreenCanvas extends EventTarget {
+    constructor(width: number, height: number);
+    width: number;
+    height: number;
+
+    getContext(
+      contextId: "2d",
+      contextAttributes?: CanvasRenderingContext2DSettings
+    ): OffscreenCanvasRenderingContext2D | null;
+
+    convertToBlob(options?: {
+      type?: string | undefined;
+      quality?: number | undefined;
+    }): Promise<Blob>;
+
+    transferToImageBitmap(): ImageBitmap;
+  }
+
+  // https://html.spec.whatwg.org/multipage/canvas.html#canvasdrawimage
+  interface CanvasDrawImage {
+    drawImage(
+      image: CanvasImageSource | OffscreenCanvas,
+      dx: number,
+      dy: number
+    ): void;
+
+    drawImage(
+      image: CanvasImageSource | OffscreenCanvas,
+      dx: number,
+      dy: number,
+      dw: number,
+      dh: number
+    ): void;
+
+    drawImage(
+      image: CanvasImageSource | OffscreenCanvas,
+      sx: number,
+      sy: number,
+      sw: number,
+      sh: number,
+      dx: number,
+      dy: number,
+      dw: number,
+      dh: number
+    ): void;
+  }
+
+  // https://html.spec.whatwg.org/multipage/imagebitmap-and-animations.html#dom-createimagebitmap
+  declare function createImageBitmap(
+    image: ImageBitmapSource | OffscreenCanvas
+  ): Promise<ImageBitmap>;
+  declare function createImageBitmap(
+    image: ImageBitmapSource | OffscreenCanvas,
+    sx: number,
+    sy: number,
+    sw: number,
+    sh: number
+  ): Promise<ImageBitmap>;
+
   // -----------------------
   // -----------------------
   // --- libdom.d.ts
@@ -1278,6 +1652,33 @@ declare global {
   type EventListenerOrEventListenerObject = EventListener | EventListenerObject;
 }
 
+declare global {
+  interface Console {
+    assert(condition?: boolean, ...data: any[]): void;
+    clear(): void;
+    count(label?: string): void;
+    countReset(label?: string): void;
+    debug(...data: any[]): void;
+    dir(item?: any, options?: any): void;
+    dirxml(...data: any[]): void;
+    error(...data: any[]): void;
+    group(...data: any[]): void;
+    groupCollapsed(...data: any[]): void;
+    groupEnd(): void;
+    info(...data: any[]): void;
+    log(...data: any[]): void;
+    table(tabularData?: any, properties?: string[]): void;
+    time(label?: string): void;
+    timeEnd(label?: string): void;
+    timeLog(label?: string, ...data: any[]): void;
+    timeStamp(label?: string): void;
+    trace(...data: any[]): void;
+    warn(...data: any[]): void;
+  }
+
+  var console: Console;
+}
+
 export {};
 
 export interface SystemError extends Error {