/*
    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 "JSPaintRenderingContext2D.h"

#include "ActiveDOMObject.h"
#include "ExtendedDOMClientIsoSubspaces.h"
#include "ExtendedDOMIsoSubspaces.h"
#include "IDLTypes.h"
#include "JSCSSStyleImageValue.h"
#include "JSCanvasFillRule.h"
#include "JSCanvasGradient.h"
#include "JSCanvasLineCap.h"
#include "JSCanvasLineJoin.h"
#include "JSCanvasPattern.h"
#include "JSDOMAttribute.h"
#include "JSDOMBinding.h"
#include "JSDOMConstructorNotConstructable.h"
#include "JSDOMConvertBase.h"
#include "JSDOMConvertBoolean.h"
#include "JSDOMConvertDictionary.h"
#include "JSDOMConvertEnumeration.h"
#include "JSDOMConvertInterface.h"
#include "JSDOMConvertNullable.h"
#include "JSDOMConvertNumbers.h"
#include "JSDOMConvertOptional.h"
#include "JSDOMConvertSequences.h"
#include "JSDOMConvertStrings.h"
#include "JSDOMConvertUnion.h"
#include "JSDOMExceptionHandling.h"
#include "JSDOMGlobalObject.h"
#include "JSDOMGlobalObjectInlines.h"
#include "JSDOMMatrix.h"
#include "JSDOMMatrix2DInit.h"
#include "JSDOMOperation.h"
#include "JSDOMPointInit.h"
#include "JSDOMWrapperCache.h"
#include "JSHTMLCanvasElement.h"
#include "JSHTMLImageElement.h"
#include "JSHTMLVideoElement.h"
#include "JSImageBitmap.h"
#include "JSImageSmoothingQuality.h"
#include "JSOffscreenCanvas.h"
#include "JSPath2D.h"
#include "JSSVGImageElement.h"
#include "JSWebCodecsVideoFrame.h"
#include "ScriptExecutionContext.h"
#include "WebCoreJSClientData.h"
#include <JavaScriptCore/FunctionPrototype.h>
#include <JavaScriptCore/HeapAnalyzer.h>
#include <JavaScriptCore/IteratorOperations.h>
#include <JavaScriptCore/JSArray.h>
#include <JavaScriptCore/JSCInlines.h>
#include <JavaScriptCore/JSDestructibleObjectHeapCellType.h>
#include <JavaScriptCore/SlotVisitorMacros.h>
#include <JavaScriptCore/SubspaceInlines.h>
#include <variant>
#include <wtf/GetPtr.h>
#include <wtf/PointerPreparations.h>
#include <wtf/URL.h>
#include <wtf/text/MakeString.h>


namespace WebCore {
using namespace JSC;

// Functions

static JSC_DECLARE_HOST_FUNCTION(jsPaintRenderingContext2DPrototypeFunction_drawImage);
static JSC_DECLARE_HOST_FUNCTION(jsPaintRenderingContext2DPrototypeFunction_beginPath);
static JSC_DECLARE_HOST_FUNCTION(jsPaintRenderingContext2DPrototypeFunction_fill);
static JSC_DECLARE_HOST_FUNCTION(jsPaintRenderingContext2DPrototypeFunction_stroke);
static JSC_DECLARE_HOST_FUNCTION(jsPaintRenderingContext2DPrototypeFunction_clip);
static JSC_DECLARE_HOST_FUNCTION(jsPaintRenderingContext2DPrototypeFunction_isPointInPath);
static JSC_DECLARE_HOST_FUNCTION(jsPaintRenderingContext2DPrototypeFunction_isPointInStroke);
static JSC_DECLARE_HOST_FUNCTION(jsPaintRenderingContext2DPrototypeFunction_createLinearGradient);
static JSC_DECLARE_HOST_FUNCTION(jsPaintRenderingContext2DPrototypeFunction_createRadialGradient);
static JSC_DECLARE_HOST_FUNCTION(jsPaintRenderingContext2DPrototypeFunction_createConicGradient);
static JSC_DECLARE_HOST_FUNCTION(jsPaintRenderingContext2DPrototypeFunction_createPattern);
static JSC_DECLARE_HOST_FUNCTION(jsPaintRenderingContext2DPrototypeFunction_closePath);
static JSC_DECLARE_HOST_FUNCTION(jsPaintRenderingContext2DPrototypeFunction_moveTo);
static JSC_DECLARE_HOST_FUNCTION(jsPaintRenderingContext2DPrototypeFunction_lineTo);
static JSC_DECLARE_HOST_FUNCTION(jsPaintRenderingContext2DPrototypeFunction_quadraticCurveTo);
static JSC_DECLARE_HOST_FUNCTION(jsPaintRenderingContext2DPrototypeFunction_bezierCurveTo);
static JSC_DECLARE_HOST_FUNCTION(jsPaintRenderingContext2DPrototypeFunction_arcTo);
static JSC_DECLARE_HOST_FUNCTION(jsPaintRenderingContext2DPrototypeFunction_rect);
static JSC_DECLARE_HOST_FUNCTION(jsPaintRenderingContext2DPrototypeFunction_roundRect);
static JSC_DECLARE_HOST_FUNCTION(jsPaintRenderingContext2DPrototypeFunction_arc);
static JSC_DECLARE_HOST_FUNCTION(jsPaintRenderingContext2DPrototypeFunction_ellipse);
static JSC_DECLARE_HOST_FUNCTION(jsPaintRenderingContext2DPrototypeFunction_setLineDash);
static JSC_DECLARE_HOST_FUNCTION(jsPaintRenderingContext2DPrototypeFunction_getLineDash);
static JSC_DECLARE_HOST_FUNCTION(jsPaintRenderingContext2DPrototypeFunction_clearRect);
static JSC_DECLARE_HOST_FUNCTION(jsPaintRenderingContext2DPrototypeFunction_fillRect);
static JSC_DECLARE_HOST_FUNCTION(jsPaintRenderingContext2DPrototypeFunction_strokeRect);
static JSC_DECLARE_HOST_FUNCTION(jsPaintRenderingContext2DPrototypeFunction_save);
static JSC_DECLARE_HOST_FUNCTION(jsPaintRenderingContext2DPrototypeFunction_restore);
static JSC_DECLARE_HOST_FUNCTION(jsPaintRenderingContext2DPrototypeFunction_reset);
static JSC_DECLARE_HOST_FUNCTION(jsPaintRenderingContext2DPrototypeFunction_scale);
static JSC_DECLARE_HOST_FUNCTION(jsPaintRenderingContext2DPrototypeFunction_rotate);
static JSC_DECLARE_HOST_FUNCTION(jsPaintRenderingContext2DPrototypeFunction_translate);
static JSC_DECLARE_HOST_FUNCTION(jsPaintRenderingContext2DPrototypeFunction_transform);
static JSC_DECLARE_HOST_FUNCTION(jsPaintRenderingContext2DPrototypeFunction_getTransform);
static JSC_DECLARE_HOST_FUNCTION(jsPaintRenderingContext2DPrototypeFunction_setTransform);
static JSC_DECLARE_HOST_FUNCTION(jsPaintRenderingContext2DPrototypeFunction_resetTransform);

// Attributes

static JSC_DECLARE_CUSTOM_GETTER(jsPaintRenderingContext2DConstructor);
static JSC_DECLARE_CUSTOM_GETTER(jsPaintRenderingContext2D_globalAlpha);
static JSC_DECLARE_CUSTOM_SETTER(setJSPaintRenderingContext2D_globalAlpha);
static JSC_DECLARE_CUSTOM_GETTER(jsPaintRenderingContext2D_globalCompositeOperation);
static JSC_DECLARE_CUSTOM_SETTER(setJSPaintRenderingContext2D_globalCompositeOperation);
static JSC_DECLARE_CUSTOM_GETTER(jsPaintRenderingContext2D_strokeStyle);
static JSC_DECLARE_CUSTOM_SETTER(setJSPaintRenderingContext2D_strokeStyle);
static JSC_DECLARE_CUSTOM_GETTER(jsPaintRenderingContext2D_fillStyle);
static JSC_DECLARE_CUSTOM_SETTER(setJSPaintRenderingContext2D_fillStyle);
static JSC_DECLARE_CUSTOM_GETTER(jsPaintRenderingContext2D_imageSmoothingEnabled);
static JSC_DECLARE_CUSTOM_SETTER(setJSPaintRenderingContext2D_imageSmoothingEnabled);
static JSC_DECLARE_CUSTOM_GETTER(jsPaintRenderingContext2D_imageSmoothingQuality);
static JSC_DECLARE_CUSTOM_SETTER(setJSPaintRenderingContext2D_imageSmoothingQuality);
static JSC_DECLARE_CUSTOM_GETTER(jsPaintRenderingContext2D_lineWidth);
static JSC_DECLARE_CUSTOM_SETTER(setJSPaintRenderingContext2D_lineWidth);
static JSC_DECLARE_CUSTOM_GETTER(jsPaintRenderingContext2D_lineCap);
static JSC_DECLARE_CUSTOM_SETTER(setJSPaintRenderingContext2D_lineCap);
static JSC_DECLARE_CUSTOM_GETTER(jsPaintRenderingContext2D_lineJoin);
static JSC_DECLARE_CUSTOM_SETTER(setJSPaintRenderingContext2D_lineJoin);
static JSC_DECLARE_CUSTOM_GETTER(jsPaintRenderingContext2D_miterLimit);
static JSC_DECLARE_CUSTOM_SETTER(setJSPaintRenderingContext2D_miterLimit);
static JSC_DECLARE_CUSTOM_GETTER(jsPaintRenderingContext2D_lineDashOffset);
static JSC_DECLARE_CUSTOM_SETTER(setJSPaintRenderingContext2D_lineDashOffset);
static JSC_DECLARE_CUSTOM_GETTER(jsPaintRenderingContext2D_shadowOffsetX);
static JSC_DECLARE_CUSTOM_SETTER(setJSPaintRenderingContext2D_shadowOffsetX);
static JSC_DECLARE_CUSTOM_GETTER(jsPaintRenderingContext2D_shadowOffsetY);
static JSC_DECLARE_CUSTOM_SETTER(setJSPaintRenderingContext2D_shadowOffsetY);
static JSC_DECLARE_CUSTOM_GETTER(jsPaintRenderingContext2D_shadowBlur);
static JSC_DECLARE_CUSTOM_SETTER(setJSPaintRenderingContext2D_shadowBlur);
static JSC_DECLARE_CUSTOM_GETTER(jsPaintRenderingContext2D_shadowColor);
static JSC_DECLARE_CUSTOM_SETTER(setJSPaintRenderingContext2D_shadowColor);

class JSPaintRenderingContext2DPrototype final : public JSC::JSNonFinalObject {
public:
    using Base = JSC::JSNonFinalObject;
    static JSPaintRenderingContext2DPrototype* create(JSC::VM& vm, JSDOMGlobalObject* globalObject, JSC::Structure* structure)
    {
        JSPaintRenderingContext2DPrototype* ptr = new (NotNull, JSC::allocateCell<JSPaintRenderingContext2DPrototype>(vm)) JSPaintRenderingContext2DPrototype(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(JSPaintRenderingContext2DPrototype, 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:
    JSPaintRenderingContext2DPrototype(JSC::VM& vm, JSC::JSGlobalObject*, JSC::Structure* structure)
        : JSC::JSNonFinalObject(vm, structure)
    {
    }

    void finishCreation(JSC::VM&);
};
STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSPaintRenderingContext2DPrototype, JSPaintRenderingContext2DPrototype::Base);

using JSPaintRenderingContext2DDOMConstructor = JSDOMConstructorNotConstructable<JSPaintRenderingContext2D>;

template<> const ClassInfo JSPaintRenderingContext2DDOMConstructor::s_info = { "PaintRenderingContext2D"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSPaintRenderingContext2DDOMConstructor) };

template<> JSValue JSPaintRenderingContext2DDOMConstructor::prototypeForStructure(JSC::VM& vm, const JSDOMGlobalObject& globalObject)
{
    UNUSED_PARAM(vm);
    return globalObject.functionPrototype();
}

template<> void JSPaintRenderingContext2DDOMConstructor::initializeProperties(VM& vm, JSDOMGlobalObject& globalObject)
{
    putDirect(vm, vm.propertyNames->length, jsNumber(0), JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::DontEnum);
    JSString* nameString = jsNontrivialString(vm, "PaintRenderingContext2D"_s);
    m_originalName.set(vm, this, nameString);
    putDirect(vm, vm.propertyNames->name, nameString, JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::DontEnum);
    putDirect(vm, vm.propertyNames->prototype, JSPaintRenderingContext2D::prototype(vm, globalObject), JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::DontDelete);
}

/* Hash table for prototype */

static const HashTableValue JSPaintRenderingContext2DPrototypeTableValues[] =
{
    { "constructor"_s, static_cast<unsigned>(PropertyAttribute::DontEnum), NoIntrinsic, { HashTableValue::GetterSetterType, jsPaintRenderingContext2DConstructor, 0 } },
    { "globalAlpha"_s, JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute, NoIntrinsic, { HashTableValue::GetterSetterType, jsPaintRenderingContext2D_globalAlpha, setJSPaintRenderingContext2D_globalAlpha } },
    { "globalCompositeOperation"_s, JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute, NoIntrinsic, { HashTableValue::GetterSetterType, jsPaintRenderingContext2D_globalCompositeOperation, setJSPaintRenderingContext2D_globalCompositeOperation } },
    { "strokeStyle"_s, JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute, NoIntrinsic, { HashTableValue::GetterSetterType, jsPaintRenderingContext2D_strokeStyle, setJSPaintRenderingContext2D_strokeStyle } },
    { "fillStyle"_s, JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute, NoIntrinsic, { HashTableValue::GetterSetterType, jsPaintRenderingContext2D_fillStyle, setJSPaintRenderingContext2D_fillStyle } },
    { "imageSmoothingEnabled"_s, JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute, NoIntrinsic, { HashTableValue::GetterSetterType, jsPaintRenderingContext2D_imageSmoothingEnabled, setJSPaintRenderingContext2D_imageSmoothingEnabled } },
    { "imageSmoothingQuality"_s, JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute, NoIntrinsic, { HashTableValue::GetterSetterType, jsPaintRenderingContext2D_imageSmoothingQuality, setJSPaintRenderingContext2D_imageSmoothingQuality } },
    { "lineWidth"_s, JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute, NoIntrinsic, { HashTableValue::GetterSetterType, jsPaintRenderingContext2D_lineWidth, setJSPaintRenderingContext2D_lineWidth } },
    { "lineCap"_s, JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute, NoIntrinsic, { HashTableValue::GetterSetterType, jsPaintRenderingContext2D_lineCap, setJSPaintRenderingContext2D_lineCap } },
    { "lineJoin"_s, JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute, NoIntrinsic, { HashTableValue::GetterSetterType, jsPaintRenderingContext2D_lineJoin, setJSPaintRenderingContext2D_lineJoin } },
    { "miterLimit"_s, JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute, NoIntrinsic, { HashTableValue::GetterSetterType, jsPaintRenderingContext2D_miterLimit, setJSPaintRenderingContext2D_miterLimit } },
    { "lineDashOffset"_s, JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute, NoIntrinsic, { HashTableValue::GetterSetterType, jsPaintRenderingContext2D_lineDashOffset, setJSPaintRenderingContext2D_lineDashOffset } },
    { "shadowOffsetX"_s, JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute, NoIntrinsic, { HashTableValue::GetterSetterType, jsPaintRenderingContext2D_shadowOffsetX, setJSPaintRenderingContext2D_shadowOffsetX } },
    { "shadowOffsetY"_s, JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute, NoIntrinsic, { HashTableValue::GetterSetterType, jsPaintRenderingContext2D_shadowOffsetY, setJSPaintRenderingContext2D_shadowOffsetY } },
    { "shadowBlur"_s, JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute, NoIntrinsic, { HashTableValue::GetterSetterType, jsPaintRenderingContext2D_shadowBlur, setJSPaintRenderingContext2D_shadowBlur } },
    { "shadowColor"_s, JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute, NoIntrinsic, { HashTableValue::GetterSetterType, jsPaintRenderingContext2D_shadowColor, setJSPaintRenderingContext2D_shadowColor } },
    { "drawImage"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, jsPaintRenderingContext2DPrototypeFunction_drawImage, 3 } },
    { "beginPath"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, jsPaintRenderingContext2DPrototypeFunction_beginPath, 0 } },
    { "fill"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, jsPaintRenderingContext2DPrototypeFunction_fill, 0 } },
    { "stroke"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, jsPaintRenderingContext2DPrototypeFunction_stroke, 0 } },
    { "clip"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, jsPaintRenderingContext2DPrototypeFunction_clip, 0 } },
    { "isPointInPath"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, jsPaintRenderingContext2DPrototypeFunction_isPointInPath, 2 } },
    { "isPointInStroke"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, jsPaintRenderingContext2DPrototypeFunction_isPointInStroke, 2 } },
    { "createLinearGradient"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, jsPaintRenderingContext2DPrototypeFunction_createLinearGradient, 4 } },
    { "createRadialGradient"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, jsPaintRenderingContext2DPrototypeFunction_createRadialGradient, 6 } },
    { "createConicGradient"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, jsPaintRenderingContext2DPrototypeFunction_createConicGradient, 3 } },
    { "createPattern"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, jsPaintRenderingContext2DPrototypeFunction_createPattern, 2 } },
    { "closePath"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, jsPaintRenderingContext2DPrototypeFunction_closePath, 0 } },
    { "moveTo"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, jsPaintRenderingContext2DPrototypeFunction_moveTo, 2 } },
    { "lineTo"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, jsPaintRenderingContext2DPrototypeFunction_lineTo, 2 } },
    { "quadraticCurveTo"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, jsPaintRenderingContext2DPrototypeFunction_quadraticCurveTo, 4 } },
    { "bezierCurveTo"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, jsPaintRenderingContext2DPrototypeFunction_bezierCurveTo, 6 } },
    { "arcTo"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, jsPaintRenderingContext2DPrototypeFunction_arcTo, 5 } },
    { "rect"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, jsPaintRenderingContext2DPrototypeFunction_rect, 4 } },
    { "roundRect"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, jsPaintRenderingContext2DPrototypeFunction_roundRect, 5 } },
    { "arc"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, jsPaintRenderingContext2DPrototypeFunction_arc, 5 } },
    { "ellipse"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, jsPaintRenderingContext2DPrototypeFunction_ellipse, 7 } },
    { "setLineDash"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, jsPaintRenderingContext2DPrototypeFunction_setLineDash, 1 } },
    { "getLineDash"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, jsPaintRenderingContext2DPrototypeFunction_getLineDash, 0 } },
    { "clearRect"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, jsPaintRenderingContext2DPrototypeFunction_clearRect, 4 } },
    { "fillRect"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, jsPaintRenderingContext2DPrototypeFunction_fillRect, 4 } },
    { "strokeRect"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, jsPaintRenderingContext2DPrototypeFunction_strokeRect, 4 } },
    { "save"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, jsPaintRenderingContext2DPrototypeFunction_save, 0 } },
    { "restore"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, jsPaintRenderingContext2DPrototypeFunction_restore, 0 } },
    { "reset"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, jsPaintRenderingContext2DPrototypeFunction_reset, 0 } },
    { "scale"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, jsPaintRenderingContext2DPrototypeFunction_scale, 2 } },
    { "rotate"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, jsPaintRenderingContext2DPrototypeFunction_rotate, 1 } },
    { "translate"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, jsPaintRenderingContext2DPrototypeFunction_translate, 2 } },
    { "transform"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, jsPaintRenderingContext2DPrototypeFunction_transform, 6 } },
    { "getTransform"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, jsPaintRenderingContext2DPrototypeFunction_getTransform, 0 } },
    { "setTransform"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, jsPaintRenderingContext2DPrototypeFunction_setTransform, 0 } },
    { "resetTransform"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, jsPaintRenderingContext2DPrototypeFunction_resetTransform, 0 } },
};

const ClassInfo JSPaintRenderingContext2DPrototype::s_info = { "PaintRenderingContext2D"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSPaintRenderingContext2DPrototype) };

void JSPaintRenderingContext2DPrototype::finishCreation(VM& vm)
{
    Base::finishCreation(vm);
    reifyStaticProperties(vm, JSPaintRenderingContext2D::info(), JSPaintRenderingContext2DPrototypeTableValues, *this);
    JSC_TO_STRING_TAG_WITHOUT_TRANSITION();
}

const ClassInfo JSPaintRenderingContext2D::s_info = { "PaintRenderingContext2D"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSPaintRenderingContext2D) };

JSPaintRenderingContext2D::JSPaintRenderingContext2D(Structure* structure, JSDOMGlobalObject& globalObject, Ref<PaintRenderingContext2D>&& impl)
    : JSDOMWrapper<PaintRenderingContext2D, SignedPtrTraits<PaintRenderingContext2D, PaintRenderingContext2DPtrTag>>(structure, globalObject, WTFMove(impl))
{
}

JSObject* JSPaintRenderingContext2D::createPrototype(VM& vm, JSDOMGlobalObject& globalObject)
{
    auto* structure = JSPaintRenderingContext2DPrototype::createStructure(vm, &globalObject, globalObject.objectPrototype());
    structure->setMayBePrototype(true);
    return JSPaintRenderingContext2DPrototype::create(vm, &globalObject, structure);
}

JSObject* JSPaintRenderingContext2D::prototype(VM& vm, JSDOMGlobalObject& globalObject)
{
    return getDOMPrototype<JSPaintRenderingContext2D>(vm, globalObject);
}

JSValue JSPaintRenderingContext2D::getConstructor(VM& vm, const JSGlobalObject* globalObject)
{
    return getDOMConstructor<JSPaintRenderingContext2DDOMConstructor, DOMConstructorID::PaintRenderingContext2D>(vm, *jsCast<const JSDOMGlobalObject*>(globalObject));
}

void JSPaintRenderingContext2D::destroy(JSC::JSCell* cell)
{
    JSPaintRenderingContext2D* thisObject = static_cast<JSPaintRenderingContext2D*>(cell);
    thisObject->JSPaintRenderingContext2D::~JSPaintRenderingContext2D();
}

JSC_DEFINE_CUSTOM_GETTER(jsPaintRenderingContext2DConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName))
{
    auto& vm = JSC::getVM(lexicalGlobalObject);
    auto throwScope = DECLARE_THROW_SCOPE(vm);
    auto* prototype = jsDynamicCast<JSPaintRenderingContext2DPrototype*>(JSValue::decode(thisValue));
    if (UNLIKELY(!prototype))
        return throwVMTypeError(lexicalGlobalObject, throwScope);
    return JSValue::encode(JSPaintRenderingContext2D::getConstructor(vm, prototype->globalObject()));
}

static inline JSValue jsPaintRenderingContext2D_globalAlphaGetter(JSGlobalObject& lexicalGlobalObject, JSPaintRenderingContext2D& thisObject)
{
    auto& vm = JSC::getVM(&lexicalGlobalObject);
    auto throwScope = DECLARE_THROW_SCOPE(vm);
    auto& impl = thisObject.wrapped();
    RELEASE_AND_RETURN(throwScope, (toJS<IDLUnrestrictedDouble>(lexicalGlobalObject, throwScope, impl.globalAlpha())));
}

JSC_DEFINE_CUSTOM_GETTER(jsPaintRenderingContext2D_globalAlpha, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
{
    return IDLAttribute<JSPaintRenderingContext2D>::get<jsPaintRenderingContext2D_globalAlphaGetter, CastedThisErrorBehavior::Assert>(*lexicalGlobalObject, thisValue, attributeName);
}

static inline bool setJSPaintRenderingContext2D_globalAlphaSetter(JSGlobalObject& lexicalGlobalObject, JSPaintRenderingContext2D& thisObject, JSValue value)
{
    auto& vm = JSC::getVM(&lexicalGlobalObject);
    UNUSED_PARAM(vm);
    auto throwScope = DECLARE_THROW_SCOPE(vm);
    auto& impl = thisObject.wrapped();
    auto nativeValueConversionResult = convert<IDLUnrestrictedDouble>(lexicalGlobalObject, value);
    if (UNLIKELY(nativeValueConversionResult.hasException(throwScope)))
        return false;
    invokeFunctorPropagatingExceptionIfNecessary(lexicalGlobalObject, throwScope, [&] {
        return impl.setGlobalAlpha(nativeValueConversionResult.releaseReturnValue());
    });
    return true;
}

JSC_DEFINE_CUSTOM_SETTER(setJSPaintRenderingContext2D_globalAlpha, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
{
    return IDLAttribute<JSPaintRenderingContext2D>::set<setJSPaintRenderingContext2D_globalAlphaSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
}

static inline JSValue jsPaintRenderingContext2D_globalCompositeOperationGetter(JSGlobalObject& lexicalGlobalObject, JSPaintRenderingContext2D& thisObject)
{
    auto& vm = JSC::getVM(&lexicalGlobalObject);
    auto throwScope = DECLARE_THROW_SCOPE(vm);
    auto& impl = thisObject.wrapped();
    RELEASE_AND_RETURN(throwScope, (toJS<IDLDOMString>(lexicalGlobalObject, throwScope, impl.globalCompositeOperation())));
}

JSC_DEFINE_CUSTOM_GETTER(jsPaintRenderingContext2D_globalCompositeOperation, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
{
    return IDLAttribute<JSPaintRenderingContext2D>::get<jsPaintRenderingContext2D_globalCompositeOperationGetter, CastedThisErrorBehavior::Assert>(*lexicalGlobalObject, thisValue, attributeName);
}

static inline bool setJSPaintRenderingContext2D_globalCompositeOperationSetter(JSGlobalObject& lexicalGlobalObject, JSPaintRenderingContext2D& thisObject, JSValue value)
{
    auto& vm = JSC::getVM(&lexicalGlobalObject);
    UNUSED_PARAM(vm);
    auto throwScope = DECLARE_THROW_SCOPE(vm);
    auto& impl = thisObject.wrapped();
    auto nativeValueConversionResult = convert<IDLDOMString>(lexicalGlobalObject, value);
    if (UNLIKELY(nativeValueConversionResult.hasException(throwScope)))
        return false;
    invokeFunctorPropagatingExceptionIfNecessary(lexicalGlobalObject, throwScope, [&] {
        return impl.setGlobalCompositeOperation(nativeValueConversionResult.releaseReturnValue());
    });
    return true;
}

JSC_DEFINE_CUSTOM_SETTER(setJSPaintRenderingContext2D_globalCompositeOperation, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
{
    return IDLAttribute<JSPaintRenderingContext2D>::set<setJSPaintRenderingContext2D_globalCompositeOperationSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
}

static inline JSValue jsPaintRenderingContext2D_strokeStyleGetter(JSGlobalObject& lexicalGlobalObject, JSPaintRenderingContext2D& thisObject)
{
    auto& vm = JSC::getVM(&lexicalGlobalObject);
    auto throwScope = DECLARE_THROW_SCOPE(vm);
    auto& impl = thisObject.wrapped();
    RELEASE_AND_RETURN(throwScope, (toJS<IDLUnion<IDLDOMString, IDLInterface<CanvasGradient>, IDLInterface<CanvasPattern>>>(lexicalGlobalObject, *thisObject.globalObject(), throwScope, impl.strokeStyle())));
}

JSC_DEFINE_CUSTOM_GETTER(jsPaintRenderingContext2D_strokeStyle, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
{
    return IDLAttribute<JSPaintRenderingContext2D>::get<jsPaintRenderingContext2D_strokeStyleGetter, CastedThisErrorBehavior::Assert>(*lexicalGlobalObject, thisValue, attributeName);
}

static inline bool setJSPaintRenderingContext2D_strokeStyleSetter(JSGlobalObject& lexicalGlobalObject, JSPaintRenderingContext2D& thisObject, JSValue value)
{
    auto& vm = JSC::getVM(&lexicalGlobalObject);
    UNUSED_PARAM(vm);
    auto throwScope = DECLARE_THROW_SCOPE(vm);
    auto& impl = thisObject.wrapped();
    auto nativeValueConversionResult = convert<IDLUnion<IDLDOMString, IDLInterface<CanvasGradient>, IDLInterface<CanvasPattern>>>(lexicalGlobalObject, value);
    if (UNLIKELY(nativeValueConversionResult.hasException(throwScope)))
        return false;
    invokeFunctorPropagatingExceptionIfNecessary(lexicalGlobalObject, throwScope, [&] {
        return impl.setStrokeStyle(nativeValueConversionResult.releaseReturnValue());
    });
    return true;
}

JSC_DEFINE_CUSTOM_SETTER(setJSPaintRenderingContext2D_strokeStyle, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
{
    return IDLAttribute<JSPaintRenderingContext2D>::set<setJSPaintRenderingContext2D_strokeStyleSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
}

static inline JSValue jsPaintRenderingContext2D_fillStyleGetter(JSGlobalObject& lexicalGlobalObject, JSPaintRenderingContext2D& thisObject)
{
    auto& vm = JSC::getVM(&lexicalGlobalObject);
    auto throwScope = DECLARE_THROW_SCOPE(vm);
    auto& impl = thisObject.wrapped();
    RELEASE_AND_RETURN(throwScope, (toJS<IDLUnion<IDLDOMString, IDLInterface<CanvasGradient>, IDLInterface<CanvasPattern>>>(lexicalGlobalObject, *thisObject.globalObject(), throwScope, impl.fillStyle())));
}

JSC_DEFINE_CUSTOM_GETTER(jsPaintRenderingContext2D_fillStyle, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
{
    return IDLAttribute<JSPaintRenderingContext2D>::get<jsPaintRenderingContext2D_fillStyleGetter, CastedThisErrorBehavior::Assert>(*lexicalGlobalObject, thisValue, attributeName);
}

static inline bool setJSPaintRenderingContext2D_fillStyleSetter(JSGlobalObject& lexicalGlobalObject, JSPaintRenderingContext2D& thisObject, JSValue value)
{
    auto& vm = JSC::getVM(&lexicalGlobalObject);
    UNUSED_PARAM(vm);
    auto throwScope = DECLARE_THROW_SCOPE(vm);
    auto& impl = thisObject.wrapped();
    auto nativeValueConversionResult = convert<IDLUnion<IDLDOMString, IDLInterface<CanvasGradient>, IDLInterface<CanvasPattern>>>(lexicalGlobalObject, value);
    if (UNLIKELY(nativeValueConversionResult.hasException(throwScope)))
        return false;
    invokeFunctorPropagatingExceptionIfNecessary(lexicalGlobalObject, throwScope, [&] {
        return impl.setFillStyle(nativeValueConversionResult.releaseReturnValue());
    });
    return true;
}

JSC_DEFINE_CUSTOM_SETTER(setJSPaintRenderingContext2D_fillStyle, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
{
    return IDLAttribute<JSPaintRenderingContext2D>::set<setJSPaintRenderingContext2D_fillStyleSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
}

static inline JSValue jsPaintRenderingContext2D_imageSmoothingEnabledGetter(JSGlobalObject& lexicalGlobalObject, JSPaintRenderingContext2D& thisObject)
{
    auto& vm = JSC::getVM(&lexicalGlobalObject);
    auto throwScope = DECLARE_THROW_SCOPE(vm);
    auto& impl = thisObject.wrapped();
    RELEASE_AND_RETURN(throwScope, (toJS<IDLBoolean>(lexicalGlobalObject, throwScope, impl.imageSmoothingEnabled())));
}

JSC_DEFINE_CUSTOM_GETTER(jsPaintRenderingContext2D_imageSmoothingEnabled, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
{
    return IDLAttribute<JSPaintRenderingContext2D>::get<jsPaintRenderingContext2D_imageSmoothingEnabledGetter, CastedThisErrorBehavior::Assert>(*lexicalGlobalObject, thisValue, attributeName);
}

static inline bool setJSPaintRenderingContext2D_imageSmoothingEnabledSetter(JSGlobalObject& lexicalGlobalObject, JSPaintRenderingContext2D& thisObject, JSValue value)
{
    auto& vm = JSC::getVM(&lexicalGlobalObject);
    UNUSED_PARAM(vm);
    auto throwScope = DECLARE_THROW_SCOPE(vm);
    auto& impl = thisObject.wrapped();
    auto nativeValueConversionResult = convert<IDLBoolean>(lexicalGlobalObject, value);
    if (UNLIKELY(nativeValueConversionResult.hasException(throwScope)))
        return false;
    invokeFunctorPropagatingExceptionIfNecessary(lexicalGlobalObject, throwScope, [&] {
        return impl.setImageSmoothingEnabled(nativeValueConversionResult.releaseReturnValue());
    });
    return true;
}

JSC_DEFINE_CUSTOM_SETTER(setJSPaintRenderingContext2D_imageSmoothingEnabled, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
{
    return IDLAttribute<JSPaintRenderingContext2D>::set<setJSPaintRenderingContext2D_imageSmoothingEnabledSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
}

static inline JSValue jsPaintRenderingContext2D_imageSmoothingQualityGetter(JSGlobalObject& lexicalGlobalObject, JSPaintRenderingContext2D& thisObject)
{
    auto& vm = JSC::getVM(&lexicalGlobalObject);
    auto throwScope = DECLARE_THROW_SCOPE(vm);
    auto& impl = thisObject.wrapped();
    RELEASE_AND_RETURN(throwScope, (toJS<IDLEnumeration<ImageSmoothingQuality>>(lexicalGlobalObject, throwScope, impl.imageSmoothingQuality())));
}

JSC_DEFINE_CUSTOM_GETTER(jsPaintRenderingContext2D_imageSmoothingQuality, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
{
    return IDLAttribute<JSPaintRenderingContext2D>::get<jsPaintRenderingContext2D_imageSmoothingQualityGetter, CastedThisErrorBehavior::Assert>(*lexicalGlobalObject, thisValue, attributeName);
}

static inline bool setJSPaintRenderingContext2D_imageSmoothingQualitySetter(JSGlobalObject& lexicalGlobalObject, JSPaintRenderingContext2D& thisObject, JSValue value)
{
    auto& vm = JSC::getVM(&lexicalGlobalObject);
    UNUSED_PARAM(vm);
    auto throwScope = DECLARE_THROW_SCOPE(vm);
    auto& impl = thisObject.wrapped();
    auto optionalNativeValue = parseEnumeration<ImageSmoothingQuality>(lexicalGlobalObject, value);
    RETURN_IF_EXCEPTION(throwScope, false);
    if (UNLIKELY(!optionalNativeValue))
        return false;
    invokeFunctorPropagatingExceptionIfNecessary(lexicalGlobalObject, throwScope, [&] {
        return impl.setImageSmoothingQuality(optionalNativeValue.value());
    });
    return true;
}

JSC_DEFINE_CUSTOM_SETTER(setJSPaintRenderingContext2D_imageSmoothingQuality, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
{
    return IDLAttribute<JSPaintRenderingContext2D>::set<setJSPaintRenderingContext2D_imageSmoothingQualitySetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
}

static inline JSValue jsPaintRenderingContext2D_lineWidthGetter(JSGlobalObject& lexicalGlobalObject, JSPaintRenderingContext2D& thisObject)
{
    auto& vm = JSC::getVM(&lexicalGlobalObject);
    auto throwScope = DECLARE_THROW_SCOPE(vm);
    auto& impl = thisObject.wrapped();
    RELEASE_AND_RETURN(throwScope, (toJS<IDLUnrestrictedDouble>(lexicalGlobalObject, throwScope, impl.lineWidth())));
}

JSC_DEFINE_CUSTOM_GETTER(jsPaintRenderingContext2D_lineWidth, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
{
    return IDLAttribute<JSPaintRenderingContext2D>::get<jsPaintRenderingContext2D_lineWidthGetter, CastedThisErrorBehavior::Assert>(*lexicalGlobalObject, thisValue, attributeName);
}

static inline bool setJSPaintRenderingContext2D_lineWidthSetter(JSGlobalObject& lexicalGlobalObject, JSPaintRenderingContext2D& thisObject, JSValue value)
{
    auto& vm = JSC::getVM(&lexicalGlobalObject);
    UNUSED_PARAM(vm);
    auto throwScope = DECLARE_THROW_SCOPE(vm);
    auto& impl = thisObject.wrapped();
    auto nativeValueConversionResult = convert<IDLUnrestrictedDouble>(lexicalGlobalObject, value);
    if (UNLIKELY(nativeValueConversionResult.hasException(throwScope)))
        return false;
    invokeFunctorPropagatingExceptionIfNecessary(lexicalGlobalObject, throwScope, [&] {
        return impl.setLineWidth(nativeValueConversionResult.releaseReturnValue());
    });
    return true;
}

JSC_DEFINE_CUSTOM_SETTER(setJSPaintRenderingContext2D_lineWidth, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
{
    return IDLAttribute<JSPaintRenderingContext2D>::set<setJSPaintRenderingContext2D_lineWidthSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
}

static inline JSValue jsPaintRenderingContext2D_lineCapGetter(JSGlobalObject& lexicalGlobalObject, JSPaintRenderingContext2D& thisObject)
{
    auto& vm = JSC::getVM(&lexicalGlobalObject);
    auto throwScope = DECLARE_THROW_SCOPE(vm);
    auto& impl = thisObject.wrapped();
    RELEASE_AND_RETURN(throwScope, (toJS<IDLEnumeration<CanvasLineCap>>(lexicalGlobalObject, throwScope, impl.lineCap())));
}

JSC_DEFINE_CUSTOM_GETTER(jsPaintRenderingContext2D_lineCap, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
{
    return IDLAttribute<JSPaintRenderingContext2D>::get<jsPaintRenderingContext2D_lineCapGetter, CastedThisErrorBehavior::Assert>(*lexicalGlobalObject, thisValue, attributeName);
}

static inline bool setJSPaintRenderingContext2D_lineCapSetter(JSGlobalObject& lexicalGlobalObject, JSPaintRenderingContext2D& thisObject, JSValue value)
{
    auto& vm = JSC::getVM(&lexicalGlobalObject);
    UNUSED_PARAM(vm);
    auto throwScope = DECLARE_THROW_SCOPE(vm);
    auto& impl = thisObject.wrapped();
    auto optionalNativeValue = parseEnumeration<CanvasLineCap>(lexicalGlobalObject, value);
    RETURN_IF_EXCEPTION(throwScope, false);
    if (UNLIKELY(!optionalNativeValue))
        return false;
    invokeFunctorPropagatingExceptionIfNecessary(lexicalGlobalObject, throwScope, [&] {
        return impl.setLineCap(optionalNativeValue.value());
    });
    return true;
}

JSC_DEFINE_CUSTOM_SETTER(setJSPaintRenderingContext2D_lineCap, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
{
    return IDLAttribute<JSPaintRenderingContext2D>::set<setJSPaintRenderingContext2D_lineCapSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
}

static inline JSValue jsPaintRenderingContext2D_lineJoinGetter(JSGlobalObject& lexicalGlobalObject, JSPaintRenderingContext2D& thisObject)
{
    auto& vm = JSC::getVM(&lexicalGlobalObject);
    auto throwScope = DECLARE_THROW_SCOPE(vm);
    auto& impl = thisObject.wrapped();
    RELEASE_AND_RETURN(throwScope, (toJS<IDLEnumeration<CanvasLineJoin>>(lexicalGlobalObject, throwScope, impl.lineJoin())));
}

JSC_DEFINE_CUSTOM_GETTER(jsPaintRenderingContext2D_lineJoin, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
{
    return IDLAttribute<JSPaintRenderingContext2D>::get<jsPaintRenderingContext2D_lineJoinGetter, CastedThisErrorBehavior::Assert>(*lexicalGlobalObject, thisValue, attributeName);
}

static inline bool setJSPaintRenderingContext2D_lineJoinSetter(JSGlobalObject& lexicalGlobalObject, JSPaintRenderingContext2D& thisObject, JSValue value)
{
    auto& vm = JSC::getVM(&lexicalGlobalObject);
    UNUSED_PARAM(vm);
    auto throwScope = DECLARE_THROW_SCOPE(vm);
    auto& impl = thisObject.wrapped();
    auto optionalNativeValue = parseEnumeration<CanvasLineJoin>(lexicalGlobalObject, value);
    RETURN_IF_EXCEPTION(throwScope, false);
    if (UNLIKELY(!optionalNativeValue))
        return false;
    invokeFunctorPropagatingExceptionIfNecessary(lexicalGlobalObject, throwScope, [&] {
        return impl.setLineJoin(optionalNativeValue.value());
    });
    return true;
}

JSC_DEFINE_CUSTOM_SETTER(setJSPaintRenderingContext2D_lineJoin, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
{
    return IDLAttribute<JSPaintRenderingContext2D>::set<setJSPaintRenderingContext2D_lineJoinSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
}

static inline JSValue jsPaintRenderingContext2D_miterLimitGetter(JSGlobalObject& lexicalGlobalObject, JSPaintRenderingContext2D& thisObject)
{
    auto& vm = JSC::getVM(&lexicalGlobalObject);
    auto throwScope = DECLARE_THROW_SCOPE(vm);
    auto& impl = thisObject.wrapped();
    RELEASE_AND_RETURN(throwScope, (toJS<IDLUnrestrictedDouble>(lexicalGlobalObject, throwScope, impl.miterLimit())));
}

JSC_DEFINE_CUSTOM_GETTER(jsPaintRenderingContext2D_miterLimit, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
{
    return IDLAttribute<JSPaintRenderingContext2D>::get<jsPaintRenderingContext2D_miterLimitGetter, CastedThisErrorBehavior::Assert>(*lexicalGlobalObject, thisValue, attributeName);
}

static inline bool setJSPaintRenderingContext2D_miterLimitSetter(JSGlobalObject& lexicalGlobalObject, JSPaintRenderingContext2D& thisObject, JSValue value)
{
    auto& vm = JSC::getVM(&lexicalGlobalObject);
    UNUSED_PARAM(vm);
    auto throwScope = DECLARE_THROW_SCOPE(vm);
    auto& impl = thisObject.wrapped();
    auto nativeValueConversionResult = convert<IDLUnrestrictedDouble>(lexicalGlobalObject, value);
    if (UNLIKELY(nativeValueConversionResult.hasException(throwScope)))
        return false;
    invokeFunctorPropagatingExceptionIfNecessary(lexicalGlobalObject, throwScope, [&] {
        return impl.setMiterLimit(nativeValueConversionResult.releaseReturnValue());
    });
    return true;
}

JSC_DEFINE_CUSTOM_SETTER(setJSPaintRenderingContext2D_miterLimit, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
{
    return IDLAttribute<JSPaintRenderingContext2D>::set<setJSPaintRenderingContext2D_miterLimitSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
}

static inline JSValue jsPaintRenderingContext2D_lineDashOffsetGetter(JSGlobalObject& lexicalGlobalObject, JSPaintRenderingContext2D& thisObject)
{
    auto& vm = JSC::getVM(&lexicalGlobalObject);
    auto throwScope = DECLARE_THROW_SCOPE(vm);
    auto& impl = thisObject.wrapped();
    RELEASE_AND_RETURN(throwScope, (toJS<IDLUnrestrictedDouble>(lexicalGlobalObject, throwScope, impl.lineDashOffset())));
}

JSC_DEFINE_CUSTOM_GETTER(jsPaintRenderingContext2D_lineDashOffset, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
{
    return IDLAttribute<JSPaintRenderingContext2D>::get<jsPaintRenderingContext2D_lineDashOffsetGetter, CastedThisErrorBehavior::Assert>(*lexicalGlobalObject, thisValue, attributeName);
}

static inline bool setJSPaintRenderingContext2D_lineDashOffsetSetter(JSGlobalObject& lexicalGlobalObject, JSPaintRenderingContext2D& thisObject, JSValue value)
{
    auto& vm = JSC::getVM(&lexicalGlobalObject);
    UNUSED_PARAM(vm);
    auto throwScope = DECLARE_THROW_SCOPE(vm);
    auto& impl = thisObject.wrapped();
    auto nativeValueConversionResult = convert<IDLUnrestrictedDouble>(lexicalGlobalObject, value);
    if (UNLIKELY(nativeValueConversionResult.hasException(throwScope)))
        return false;
    invokeFunctorPropagatingExceptionIfNecessary(lexicalGlobalObject, throwScope, [&] {
        return impl.setLineDashOffset(nativeValueConversionResult.releaseReturnValue());
    });
    return true;
}

JSC_DEFINE_CUSTOM_SETTER(setJSPaintRenderingContext2D_lineDashOffset, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
{
    return IDLAttribute<JSPaintRenderingContext2D>::set<setJSPaintRenderingContext2D_lineDashOffsetSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
}

static inline JSValue jsPaintRenderingContext2D_shadowOffsetXGetter(JSGlobalObject& lexicalGlobalObject, JSPaintRenderingContext2D& thisObject)
{
    auto& vm = JSC::getVM(&lexicalGlobalObject);
    auto throwScope = DECLARE_THROW_SCOPE(vm);
    auto& impl = thisObject.wrapped();
    RELEASE_AND_RETURN(throwScope, (toJS<IDLUnrestrictedDouble>(lexicalGlobalObject, throwScope, impl.shadowOffsetX())));
}

JSC_DEFINE_CUSTOM_GETTER(jsPaintRenderingContext2D_shadowOffsetX, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
{
    return IDLAttribute<JSPaintRenderingContext2D>::get<jsPaintRenderingContext2D_shadowOffsetXGetter, CastedThisErrorBehavior::Assert>(*lexicalGlobalObject, thisValue, attributeName);
}

static inline bool setJSPaintRenderingContext2D_shadowOffsetXSetter(JSGlobalObject& lexicalGlobalObject, JSPaintRenderingContext2D& thisObject, JSValue value)
{
    auto& vm = JSC::getVM(&lexicalGlobalObject);
    UNUSED_PARAM(vm);
    auto throwScope = DECLARE_THROW_SCOPE(vm);
    auto& impl = thisObject.wrapped();
    auto nativeValueConversionResult = convert<IDLUnrestrictedDouble>(lexicalGlobalObject, value);
    if (UNLIKELY(nativeValueConversionResult.hasException(throwScope)))
        return false;
    invokeFunctorPropagatingExceptionIfNecessary(lexicalGlobalObject, throwScope, [&] {
        return impl.setShadowOffsetX(nativeValueConversionResult.releaseReturnValue());
    });
    return true;
}

JSC_DEFINE_CUSTOM_SETTER(setJSPaintRenderingContext2D_shadowOffsetX, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
{
    return IDLAttribute<JSPaintRenderingContext2D>::set<setJSPaintRenderingContext2D_shadowOffsetXSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
}

static inline JSValue jsPaintRenderingContext2D_shadowOffsetYGetter(JSGlobalObject& lexicalGlobalObject, JSPaintRenderingContext2D& thisObject)
{
    auto& vm = JSC::getVM(&lexicalGlobalObject);
    auto throwScope = DECLARE_THROW_SCOPE(vm);
    auto& impl = thisObject.wrapped();
    RELEASE_AND_RETURN(throwScope, (toJS<IDLUnrestrictedDouble>(lexicalGlobalObject, throwScope, impl.shadowOffsetY())));
}

JSC_DEFINE_CUSTOM_GETTER(jsPaintRenderingContext2D_shadowOffsetY, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
{
    return IDLAttribute<JSPaintRenderingContext2D>::get<jsPaintRenderingContext2D_shadowOffsetYGetter, CastedThisErrorBehavior::Assert>(*lexicalGlobalObject, thisValue, attributeName);
}

static inline bool setJSPaintRenderingContext2D_shadowOffsetYSetter(JSGlobalObject& lexicalGlobalObject, JSPaintRenderingContext2D& thisObject, JSValue value)
{
    auto& vm = JSC::getVM(&lexicalGlobalObject);
    UNUSED_PARAM(vm);
    auto throwScope = DECLARE_THROW_SCOPE(vm);
    auto& impl = thisObject.wrapped();
    auto nativeValueConversionResult = convert<IDLUnrestrictedDouble>(lexicalGlobalObject, value);
    if (UNLIKELY(nativeValueConversionResult.hasException(throwScope)))
        return false;
    invokeFunctorPropagatingExceptionIfNecessary(lexicalGlobalObject, throwScope, [&] {
        return impl.setShadowOffsetY(nativeValueConversionResult.releaseReturnValue());
    });
    return true;
}

JSC_DEFINE_CUSTOM_SETTER(setJSPaintRenderingContext2D_shadowOffsetY, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
{
    return IDLAttribute<JSPaintRenderingContext2D>::set<setJSPaintRenderingContext2D_shadowOffsetYSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
}

static inline JSValue jsPaintRenderingContext2D_shadowBlurGetter(JSGlobalObject& lexicalGlobalObject, JSPaintRenderingContext2D& thisObject)
{
    auto& vm = JSC::getVM(&lexicalGlobalObject);
    auto throwScope = DECLARE_THROW_SCOPE(vm);
    auto& impl = thisObject.wrapped();
    RELEASE_AND_RETURN(throwScope, (toJS<IDLUnrestrictedDouble>(lexicalGlobalObject, throwScope, impl.shadowBlur())));
}

JSC_DEFINE_CUSTOM_GETTER(jsPaintRenderingContext2D_shadowBlur, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
{
    return IDLAttribute<JSPaintRenderingContext2D>::get<jsPaintRenderingContext2D_shadowBlurGetter, CastedThisErrorBehavior::Assert>(*lexicalGlobalObject, thisValue, attributeName);
}

static inline bool setJSPaintRenderingContext2D_shadowBlurSetter(JSGlobalObject& lexicalGlobalObject, JSPaintRenderingContext2D& thisObject, JSValue value)
{
    auto& vm = JSC::getVM(&lexicalGlobalObject);
    UNUSED_PARAM(vm);
    auto throwScope = DECLARE_THROW_SCOPE(vm);
    auto& impl = thisObject.wrapped();
    auto nativeValueConversionResult = convert<IDLUnrestrictedDouble>(lexicalGlobalObject, value);
    if (UNLIKELY(nativeValueConversionResult.hasException(throwScope)))
        return false;
    invokeFunctorPropagatingExceptionIfNecessary(lexicalGlobalObject, throwScope, [&] {
        return impl.setShadowBlur(nativeValueConversionResult.releaseReturnValue());
    });
    return true;
}

JSC_DEFINE_CUSTOM_SETTER(setJSPaintRenderingContext2D_shadowBlur, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
{
    return IDLAttribute<JSPaintRenderingContext2D>::set<setJSPaintRenderingContext2D_shadowBlurSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
}

static inline JSValue jsPaintRenderingContext2D_shadowColorGetter(JSGlobalObject& lexicalGlobalObject, JSPaintRenderingContext2D& thisObject)
{
    auto& vm = JSC::getVM(&lexicalGlobalObject);
    auto throwScope = DECLARE_THROW_SCOPE(vm);
    auto& impl = thisObject.wrapped();
    RELEASE_AND_RETURN(throwScope, (toJS<IDLDOMString>(lexicalGlobalObject, throwScope, impl.shadowColor())));
}

JSC_DEFINE_CUSTOM_GETTER(jsPaintRenderingContext2D_shadowColor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
{
    return IDLAttribute<JSPaintRenderingContext2D>::get<jsPaintRenderingContext2D_shadowColorGetter, CastedThisErrorBehavior::Assert>(*lexicalGlobalObject, thisValue, attributeName);
}

static inline bool setJSPaintRenderingContext2D_shadowColorSetter(JSGlobalObject& lexicalGlobalObject, JSPaintRenderingContext2D& thisObject, JSValue value)
{
    auto& vm = JSC::getVM(&lexicalGlobalObject);
    UNUSED_PARAM(vm);
    auto throwScope = DECLARE_THROW_SCOPE(vm);
    auto& impl = thisObject.wrapped();
    auto nativeValueConversionResult = convert<IDLDOMString>(lexicalGlobalObject, value);
    if (UNLIKELY(nativeValueConversionResult.hasException(throwScope)))
        return false;
    invokeFunctorPropagatingExceptionIfNecessary(lexicalGlobalObject, throwScope, [&] {
        return impl.setShadowColor(nativeValueConversionResult.releaseReturnValue());
    });
    return true;
}

JSC_DEFINE_CUSTOM_SETTER(setJSPaintRenderingContext2D_shadowColor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
{
    return IDLAttribute<JSPaintRenderingContext2D>::set<setJSPaintRenderingContext2D_shadowColorSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
}

static inline JSC::EncodedJSValue jsPaintRenderingContext2DPrototypeFunction_drawImage1Body(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSPaintRenderingContext2D>::ClassParameter castedThis)
{
    auto& vm = JSC::getVM(lexicalGlobalObject);
    auto throwScope = DECLARE_THROW_SCOPE(vm);
    UNUSED_PARAM(throwScope);
    UNUSED_PARAM(callFrame);
    auto& impl = castedThis->wrapped();
    EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
    auto imageConversionResult = convert<IDLUnion<IDLInterface<HTMLImageElement>, IDLInterface<SVGImageElement>, IDLInterface<HTMLCanvasElement>, IDLInterface<ImageBitmap>, IDLInterface<CSSStyleImageValue>, IDLInterface<OffscreenCanvas>, IDLInterface<HTMLVideoElement>, IDLInterface<WebCodecsVideoFrame>>>(*lexicalGlobalObject, argument0.value());
    if (UNLIKELY(imageConversionResult.hasException(throwScope)))
       return encodedJSValue();
    EnsureStillAliveScope argument1 = callFrame->uncheckedArgument(1);
    auto dxConversionResult = convert<IDLUnrestrictedDouble>(*lexicalGlobalObject, argument1.value());
    if (UNLIKELY(dxConversionResult.hasException(throwScope)))
       return encodedJSValue();
    EnsureStillAliveScope argument2 = callFrame->uncheckedArgument(2);
    auto dyConversionResult = convert<IDLUnrestrictedDouble>(*lexicalGlobalObject, argument2.value());
    if (UNLIKELY(dyConversionResult.hasException(throwScope)))
       return encodedJSValue();
    RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.drawImage(imageConversionResult.releaseReturnValue(), dxConversionResult.releaseReturnValue(), dyConversionResult.releaseReturnValue()); })));
}

static inline JSC::EncodedJSValue jsPaintRenderingContext2DPrototypeFunction_drawImage2Body(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSPaintRenderingContext2D>::ClassParameter castedThis)
{
    auto& vm = JSC::getVM(lexicalGlobalObject);
    auto throwScope = DECLARE_THROW_SCOPE(vm);
    UNUSED_PARAM(throwScope);
    UNUSED_PARAM(callFrame);
    auto& impl = castedThis->wrapped();
    EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
    auto imageConversionResult = convert<IDLUnion<IDLInterface<HTMLImageElement>, IDLInterface<SVGImageElement>, IDLInterface<HTMLCanvasElement>, IDLInterface<ImageBitmap>, IDLInterface<CSSStyleImageValue>, IDLInterface<OffscreenCanvas>, IDLInterface<HTMLVideoElement>, IDLInterface<WebCodecsVideoFrame>>>(*lexicalGlobalObject, argument0.value());
    if (UNLIKELY(imageConversionResult.hasException(throwScope)))
       return encodedJSValue();
    EnsureStillAliveScope argument1 = callFrame->uncheckedArgument(1);
    auto dxConversionResult = convert<IDLUnrestrictedDouble>(*lexicalGlobalObject, argument1.value());
    if (UNLIKELY(dxConversionResult.hasException(throwScope)))
       return encodedJSValue();
    EnsureStillAliveScope argument2 = callFrame->uncheckedArgument(2);
    auto dyConversionResult = convert<IDLUnrestrictedDouble>(*lexicalGlobalObject, argument2.value());
    if (UNLIKELY(dyConversionResult.hasException(throwScope)))
       return encodedJSValue();
    EnsureStillAliveScope argument3 = callFrame->uncheckedArgument(3);
    auto dwConversionResult = convert<IDLUnrestrictedDouble>(*lexicalGlobalObject, argument3.value());
    if (UNLIKELY(dwConversionResult.hasException(throwScope)))
       return encodedJSValue();
    EnsureStillAliveScope argument4 = callFrame->uncheckedArgument(4);
    auto dhConversionResult = convert<IDLUnrestrictedDouble>(*lexicalGlobalObject, argument4.value());
    if (UNLIKELY(dhConversionResult.hasException(throwScope)))
       return encodedJSValue();
    RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.drawImage(imageConversionResult.releaseReturnValue(), dxConversionResult.releaseReturnValue(), dyConversionResult.releaseReturnValue(), dwConversionResult.releaseReturnValue(), dhConversionResult.releaseReturnValue()); })));
}

static inline JSC::EncodedJSValue jsPaintRenderingContext2DPrototypeFunction_drawImage3Body(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSPaintRenderingContext2D>::ClassParameter castedThis)
{
    auto& vm = JSC::getVM(lexicalGlobalObject);
    auto throwScope = DECLARE_THROW_SCOPE(vm);
    UNUSED_PARAM(throwScope);
    UNUSED_PARAM(callFrame);
    auto& impl = castedThis->wrapped();
    EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
    auto imageConversionResult = convert<IDLUnion<IDLInterface<HTMLImageElement>, IDLInterface<SVGImageElement>, IDLInterface<HTMLCanvasElement>, IDLInterface<ImageBitmap>, IDLInterface<CSSStyleImageValue>, IDLInterface<OffscreenCanvas>, IDLInterface<HTMLVideoElement>, IDLInterface<WebCodecsVideoFrame>>>(*lexicalGlobalObject, argument0.value());
    if (UNLIKELY(imageConversionResult.hasException(throwScope)))
       return encodedJSValue();
    EnsureStillAliveScope argument1 = callFrame->uncheckedArgument(1);
    auto sxConversionResult = convert<IDLUnrestrictedDouble>(*lexicalGlobalObject, argument1.value());
    if (UNLIKELY(sxConversionResult.hasException(throwScope)))
       return encodedJSValue();
    EnsureStillAliveScope argument2 = callFrame->uncheckedArgument(2);
    auto syConversionResult = convert<IDLUnrestrictedDouble>(*lexicalGlobalObject, argument2.value());
    if (UNLIKELY(syConversionResult.hasException(throwScope)))
       return encodedJSValue();
    EnsureStillAliveScope argument3 = callFrame->uncheckedArgument(3);
    auto swConversionResult = convert<IDLUnrestrictedDouble>(*lexicalGlobalObject, argument3.value());
    if (UNLIKELY(swConversionResult.hasException(throwScope)))
       return encodedJSValue();
    EnsureStillAliveScope argument4 = callFrame->uncheckedArgument(4);
    auto shConversionResult = convert<IDLUnrestrictedDouble>(*lexicalGlobalObject, argument4.value());
    if (UNLIKELY(shConversionResult.hasException(throwScope)))
       return encodedJSValue();
    EnsureStillAliveScope argument5 = callFrame->uncheckedArgument(5);
    auto dxConversionResult = convert<IDLUnrestrictedDouble>(*lexicalGlobalObject, argument5.value());
    if (UNLIKELY(dxConversionResult.hasException(throwScope)))
       return encodedJSValue();
    EnsureStillAliveScope argument6 = callFrame->uncheckedArgument(6);
    auto dyConversionResult = convert<IDLUnrestrictedDouble>(*lexicalGlobalObject, argument6.value());
    if (UNLIKELY(dyConversionResult.hasException(throwScope)))
       return encodedJSValue();
    EnsureStillAliveScope argument7 = callFrame->uncheckedArgument(7);
    auto dwConversionResult = convert<IDLUnrestrictedDouble>(*lexicalGlobalObject, argument7.value());
    if (UNLIKELY(dwConversionResult.hasException(throwScope)))
       return encodedJSValue();
    EnsureStillAliveScope argument8 = callFrame->uncheckedArgument(8);
    auto dhConversionResult = convert<IDLUnrestrictedDouble>(*lexicalGlobalObject, argument8.value());
    if (UNLIKELY(dhConversionResult.hasException(throwScope)))
       return encodedJSValue();
    RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.drawImage(imageConversionResult.releaseReturnValue(), sxConversionResult.releaseReturnValue(), syConversionResult.releaseReturnValue(), swConversionResult.releaseReturnValue(), shConversionResult.releaseReturnValue(), dxConversionResult.releaseReturnValue(), dyConversionResult.releaseReturnValue(), dwConversionResult.releaseReturnValue(), dhConversionResult.releaseReturnValue()); })));
}

static inline JSC::EncodedJSValue jsPaintRenderingContext2DPrototypeFunction_drawImageOverloadDispatcher(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSPaintRenderingContext2D>::ClassParameter castedThis)
{
    auto& vm = JSC::getVM(lexicalGlobalObject);
    auto throwScope = DECLARE_THROW_SCOPE(vm);
    UNUSED_PARAM(throwScope);
    UNUSED_PARAM(callFrame);
    size_t argsCount = std::min<size_t>(9, callFrame->argumentCount());
    if (argsCount == 3) {
        RELEASE_AND_RETURN(throwScope, (jsPaintRenderingContext2DPrototypeFunction_drawImage1Body(lexicalGlobalObject, callFrame, castedThis)));
    }
    if (argsCount == 5) {
        RELEASE_AND_RETURN(throwScope, (jsPaintRenderingContext2DPrototypeFunction_drawImage2Body(lexicalGlobalObject, callFrame, castedThis)));
    }
    if (argsCount == 9) {
        RELEASE_AND_RETURN(throwScope, (jsPaintRenderingContext2DPrototypeFunction_drawImage3Body(lexicalGlobalObject, callFrame, castedThis)));
    }
    return argsCount < 3 ? throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject)) : throwVMTypeError(lexicalGlobalObject, throwScope);
}

JSC_DEFINE_HOST_FUNCTION(jsPaintRenderingContext2DPrototypeFunction_drawImage, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
{
    return IDLOperation<JSPaintRenderingContext2D>::call<jsPaintRenderingContext2DPrototypeFunction_drawImageOverloadDispatcher>(*lexicalGlobalObject, *callFrame, "drawImage");
}

static inline JSC::EncodedJSValue jsPaintRenderingContext2DPrototypeFunction_beginPathBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSPaintRenderingContext2D>::ClassParameter castedThis)
{
    auto& vm = JSC::getVM(lexicalGlobalObject);
    auto throwScope = DECLARE_THROW_SCOPE(vm);
    UNUSED_PARAM(throwScope);
    UNUSED_PARAM(callFrame);
    auto& impl = castedThis->wrapped();
    RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.beginPath(); })));
}

JSC_DEFINE_HOST_FUNCTION(jsPaintRenderingContext2DPrototypeFunction_beginPath, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
{
    return IDLOperation<JSPaintRenderingContext2D>::call<jsPaintRenderingContext2DPrototypeFunction_beginPathBody>(*lexicalGlobalObject, *callFrame, "beginPath");
}

static inline JSC::EncodedJSValue jsPaintRenderingContext2DPrototypeFunction_fill1Body(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSPaintRenderingContext2D>::ClassParameter castedThis)
{
    auto& vm = JSC::getVM(lexicalGlobalObject);
    auto throwScope = DECLARE_THROW_SCOPE(vm);
    UNUSED_PARAM(throwScope);
    UNUSED_PARAM(callFrame);
    auto& impl = castedThis->wrapped();
    EnsureStillAliveScope argument0 = callFrame->argument(0);
    auto fillRuleConversionResult = convertOptionalWithDefault<IDLEnumeration<CanvasFillRule>>(*lexicalGlobalObject, argument0.value(), [&]() -> ConversionResult<IDLEnumeration<CanvasFillRule>> { return Converter<IDLEnumeration<CanvasFillRule>>::ReturnType { CanvasFillRule::Nonzero }; }, [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentMustBeEnumError(lexicalGlobalObject, scope, 0, "fillRule"_s, "PaintRenderingContext2D"_s, "fill"_s, expectedEnumerationValues<CanvasFillRule>()); });
    if (UNLIKELY(fillRuleConversionResult.hasException(throwScope)))
       return encodedJSValue();
    RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.fill(fillRuleConversionResult.releaseReturnValue()); })));
}

static inline JSC::EncodedJSValue jsPaintRenderingContext2DPrototypeFunction_fill2Body(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSPaintRenderingContext2D>::ClassParameter castedThis)
{
    auto& vm = JSC::getVM(lexicalGlobalObject);
    auto throwScope = DECLARE_THROW_SCOPE(vm);
    UNUSED_PARAM(throwScope);
    UNUSED_PARAM(callFrame);
    auto& impl = castedThis->wrapped();
    EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
    auto pathConversionResult = convert<IDLInterface<Path2D>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "path"_s, "PaintRenderingContext2D"_s, "fill"_s, "Path2D"_s); });
    if (UNLIKELY(pathConversionResult.hasException(throwScope)))
       return encodedJSValue();
    EnsureStillAliveScope argument1 = callFrame->argument(1);
    auto fillRuleConversionResult = convertOptionalWithDefault<IDLEnumeration<CanvasFillRule>>(*lexicalGlobalObject, argument1.value(), [&]() -> ConversionResult<IDLEnumeration<CanvasFillRule>> { return Converter<IDLEnumeration<CanvasFillRule>>::ReturnType { CanvasFillRule::Nonzero }; }, [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentMustBeEnumError(lexicalGlobalObject, scope, 1, "fillRule"_s, "PaintRenderingContext2D"_s, "fill"_s, expectedEnumerationValues<CanvasFillRule>()); });
    if (UNLIKELY(fillRuleConversionResult.hasException(throwScope)))
       return encodedJSValue();
    RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.fill(*pathConversionResult.releaseReturnValue(), fillRuleConversionResult.releaseReturnValue()); })));
}

static inline JSC::EncodedJSValue jsPaintRenderingContext2DPrototypeFunction_fillOverloadDispatcher(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSPaintRenderingContext2D>::ClassParameter castedThis)
{
    auto& vm = JSC::getVM(lexicalGlobalObject);
    auto throwScope = DECLARE_THROW_SCOPE(vm);
    UNUSED_PARAM(throwScope);
    UNUSED_PARAM(callFrame);
    size_t argsCount = std::min<size_t>(2, callFrame->argumentCount());
    if (argsCount == 0) {
        RELEASE_AND_RETURN(throwScope, (jsPaintRenderingContext2DPrototypeFunction_fill1Body(lexicalGlobalObject, callFrame, castedThis)));
    }
    if (argsCount == 1) {
        JSValue distinguishingArg = callFrame->uncheckedArgument(0);
        if (distinguishingArg.isUndefined())
            RELEASE_AND_RETURN(throwScope, (jsPaintRenderingContext2DPrototypeFunction_fill1Body(lexicalGlobalObject, callFrame, castedThis)));
        if (distinguishingArg.isObject() && asObject(distinguishingArg)->inherits<JSPath2D>())
            RELEASE_AND_RETURN(throwScope, (jsPaintRenderingContext2DPrototypeFunction_fill2Body(lexicalGlobalObject, callFrame, castedThis)));
        RELEASE_AND_RETURN(throwScope, (jsPaintRenderingContext2DPrototypeFunction_fill1Body(lexicalGlobalObject, callFrame, castedThis)));
    }
    if (argsCount == 2) {
        RELEASE_AND_RETURN(throwScope, (jsPaintRenderingContext2DPrototypeFunction_fill2Body(lexicalGlobalObject, callFrame, castedThis)));
    }
    return throwVMTypeError(lexicalGlobalObject, throwScope);
}

JSC_DEFINE_HOST_FUNCTION(jsPaintRenderingContext2DPrototypeFunction_fill, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
{
    return IDLOperation<JSPaintRenderingContext2D>::call<jsPaintRenderingContext2DPrototypeFunction_fillOverloadDispatcher>(*lexicalGlobalObject, *callFrame, "fill");
}

static inline JSC::EncodedJSValue jsPaintRenderingContext2DPrototypeFunction_stroke1Body(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSPaintRenderingContext2D>::ClassParameter castedThis)
{
    auto& vm = JSC::getVM(lexicalGlobalObject);
    auto throwScope = DECLARE_THROW_SCOPE(vm);
    UNUSED_PARAM(throwScope);
    UNUSED_PARAM(callFrame);
    auto& impl = castedThis->wrapped();
    RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.stroke(); })));
}

static inline JSC::EncodedJSValue jsPaintRenderingContext2DPrototypeFunction_stroke2Body(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSPaintRenderingContext2D>::ClassParameter castedThis)
{
    auto& vm = JSC::getVM(lexicalGlobalObject);
    auto throwScope = DECLARE_THROW_SCOPE(vm);
    UNUSED_PARAM(throwScope);
    UNUSED_PARAM(callFrame);
    auto& impl = castedThis->wrapped();
    EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
    auto pathConversionResult = convert<IDLInterface<Path2D>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "path"_s, "PaintRenderingContext2D"_s, "stroke"_s, "Path2D"_s); });
    if (UNLIKELY(pathConversionResult.hasException(throwScope)))
       return encodedJSValue();
    RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.stroke(*pathConversionResult.releaseReturnValue()); })));
}

static inline JSC::EncodedJSValue jsPaintRenderingContext2DPrototypeFunction_strokeOverloadDispatcher(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSPaintRenderingContext2D>::ClassParameter castedThis)
{
    auto& vm = JSC::getVM(lexicalGlobalObject);
    auto throwScope = DECLARE_THROW_SCOPE(vm);
    UNUSED_PARAM(throwScope);
    UNUSED_PARAM(callFrame);
    size_t argsCount = std::min<size_t>(1, callFrame->argumentCount());
    if (argsCount == 0) {
        RELEASE_AND_RETURN(throwScope, (jsPaintRenderingContext2DPrototypeFunction_stroke1Body(lexicalGlobalObject, callFrame, castedThis)));
    }
    if (argsCount == 1) {
        RELEASE_AND_RETURN(throwScope, (jsPaintRenderingContext2DPrototypeFunction_stroke2Body(lexicalGlobalObject, callFrame, castedThis)));
    }
    return throwVMTypeError(lexicalGlobalObject, throwScope);
}

JSC_DEFINE_HOST_FUNCTION(jsPaintRenderingContext2DPrototypeFunction_stroke, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
{
    return IDLOperation<JSPaintRenderingContext2D>::call<jsPaintRenderingContext2DPrototypeFunction_strokeOverloadDispatcher>(*lexicalGlobalObject, *callFrame, "stroke");
}

static inline JSC::EncodedJSValue jsPaintRenderingContext2DPrototypeFunction_clip1Body(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSPaintRenderingContext2D>::ClassParameter castedThis)
{
    auto& vm = JSC::getVM(lexicalGlobalObject);
    auto throwScope = DECLARE_THROW_SCOPE(vm);
    UNUSED_PARAM(throwScope);
    UNUSED_PARAM(callFrame);
    auto& impl = castedThis->wrapped();
    EnsureStillAliveScope argument0 = callFrame->argument(0);
    auto fillRuleConversionResult = convertOptionalWithDefault<IDLEnumeration<CanvasFillRule>>(*lexicalGlobalObject, argument0.value(), [&]() -> ConversionResult<IDLEnumeration<CanvasFillRule>> { return Converter<IDLEnumeration<CanvasFillRule>>::ReturnType { CanvasFillRule::Nonzero }; }, [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentMustBeEnumError(lexicalGlobalObject, scope, 0, "fillRule"_s, "PaintRenderingContext2D"_s, "clip"_s, expectedEnumerationValues<CanvasFillRule>()); });
    if (UNLIKELY(fillRuleConversionResult.hasException(throwScope)))
       return encodedJSValue();
    RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.clip(fillRuleConversionResult.releaseReturnValue()); })));
}

static inline JSC::EncodedJSValue jsPaintRenderingContext2DPrototypeFunction_clip2Body(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSPaintRenderingContext2D>::ClassParameter castedThis)
{
    auto& vm = JSC::getVM(lexicalGlobalObject);
    auto throwScope = DECLARE_THROW_SCOPE(vm);
    UNUSED_PARAM(throwScope);
    UNUSED_PARAM(callFrame);
    auto& impl = castedThis->wrapped();
    EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
    auto pathConversionResult = convert<IDLInterface<Path2D>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "path"_s, "PaintRenderingContext2D"_s, "clip"_s, "Path2D"_s); });
    if (UNLIKELY(pathConversionResult.hasException(throwScope)))
       return encodedJSValue();
    EnsureStillAliveScope argument1 = callFrame->argument(1);
    auto fillRuleConversionResult = convertOptionalWithDefault<IDLEnumeration<CanvasFillRule>>(*lexicalGlobalObject, argument1.value(), [&]() -> ConversionResult<IDLEnumeration<CanvasFillRule>> { return Converter<IDLEnumeration<CanvasFillRule>>::ReturnType { CanvasFillRule::Nonzero }; }, [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentMustBeEnumError(lexicalGlobalObject, scope, 1, "fillRule"_s, "PaintRenderingContext2D"_s, "clip"_s, expectedEnumerationValues<CanvasFillRule>()); });
    if (UNLIKELY(fillRuleConversionResult.hasException(throwScope)))
       return encodedJSValue();
    RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.clip(*pathConversionResult.releaseReturnValue(), fillRuleConversionResult.releaseReturnValue()); })));
}

static inline JSC::EncodedJSValue jsPaintRenderingContext2DPrototypeFunction_clipOverloadDispatcher(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSPaintRenderingContext2D>::ClassParameter castedThis)
{
    auto& vm = JSC::getVM(lexicalGlobalObject);
    auto throwScope = DECLARE_THROW_SCOPE(vm);
    UNUSED_PARAM(throwScope);
    UNUSED_PARAM(callFrame);
    size_t argsCount = std::min<size_t>(2, callFrame->argumentCount());
    if (argsCount == 0) {
        RELEASE_AND_RETURN(throwScope, (jsPaintRenderingContext2DPrototypeFunction_clip1Body(lexicalGlobalObject, callFrame, castedThis)));
    }
    if (argsCount == 1) {
        JSValue distinguishingArg = callFrame->uncheckedArgument(0);
        if (distinguishingArg.isUndefined())
            RELEASE_AND_RETURN(throwScope, (jsPaintRenderingContext2DPrototypeFunction_clip1Body(lexicalGlobalObject, callFrame, castedThis)));
        if (distinguishingArg.isObject() && asObject(distinguishingArg)->inherits<JSPath2D>())
            RELEASE_AND_RETURN(throwScope, (jsPaintRenderingContext2DPrototypeFunction_clip2Body(lexicalGlobalObject, callFrame, castedThis)));
        RELEASE_AND_RETURN(throwScope, (jsPaintRenderingContext2DPrototypeFunction_clip1Body(lexicalGlobalObject, callFrame, castedThis)));
    }
    if (argsCount == 2) {
        RELEASE_AND_RETURN(throwScope, (jsPaintRenderingContext2DPrototypeFunction_clip2Body(lexicalGlobalObject, callFrame, castedThis)));
    }
    return throwVMTypeError(lexicalGlobalObject, throwScope);
}

JSC_DEFINE_HOST_FUNCTION(jsPaintRenderingContext2DPrototypeFunction_clip, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
{
    return IDLOperation<JSPaintRenderingContext2D>::call<jsPaintRenderingContext2DPrototypeFunction_clipOverloadDispatcher>(*lexicalGlobalObject, *callFrame, "clip");
}

static inline JSC::EncodedJSValue jsPaintRenderingContext2DPrototypeFunction_isPointInPath1Body(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSPaintRenderingContext2D>::ClassParameter castedThis)
{
    auto& vm = JSC::getVM(lexicalGlobalObject);
    auto throwScope = DECLARE_THROW_SCOPE(vm);
    UNUSED_PARAM(throwScope);
    UNUSED_PARAM(callFrame);
    auto& impl = castedThis->wrapped();
    EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
    auto xConversionResult = convert<IDLUnrestrictedDouble>(*lexicalGlobalObject, argument0.value());
    if (UNLIKELY(xConversionResult.hasException(throwScope)))
       return encodedJSValue();
    EnsureStillAliveScope argument1 = callFrame->uncheckedArgument(1);
    auto yConversionResult = convert<IDLUnrestrictedDouble>(*lexicalGlobalObject, argument1.value());
    if (UNLIKELY(yConversionResult.hasException(throwScope)))
       return encodedJSValue();
    EnsureStillAliveScope argument2 = callFrame->argument(2);
    auto fillRuleConversionResult = convertOptionalWithDefault<IDLEnumeration<CanvasFillRule>>(*lexicalGlobalObject, argument2.value(), [&]() -> ConversionResult<IDLEnumeration<CanvasFillRule>> { return Converter<IDLEnumeration<CanvasFillRule>>::ReturnType { CanvasFillRule::Nonzero }; }, [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentMustBeEnumError(lexicalGlobalObject, scope, 2, "fillRule"_s, "PaintRenderingContext2D"_s, "isPointInPath"_s, expectedEnumerationValues<CanvasFillRule>()); });
    if (UNLIKELY(fillRuleConversionResult.hasException(throwScope)))
       return encodedJSValue();
    RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLBoolean>(*lexicalGlobalObject, throwScope, impl.isPointInPath(xConversionResult.releaseReturnValue(), yConversionResult.releaseReturnValue(), fillRuleConversionResult.releaseReturnValue()))));
}

static inline JSC::EncodedJSValue jsPaintRenderingContext2DPrototypeFunction_isPointInPath2Body(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSPaintRenderingContext2D>::ClassParameter castedThis)
{
    auto& vm = JSC::getVM(lexicalGlobalObject);
    auto throwScope = DECLARE_THROW_SCOPE(vm);
    UNUSED_PARAM(throwScope);
    UNUSED_PARAM(callFrame);
    auto& impl = castedThis->wrapped();
    EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
    auto pathConversionResult = convert<IDLInterface<Path2D>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "path"_s, "PaintRenderingContext2D"_s, "isPointInPath"_s, "Path2D"_s); });
    if (UNLIKELY(pathConversionResult.hasException(throwScope)))
       return encodedJSValue();
    EnsureStillAliveScope argument1 = callFrame->uncheckedArgument(1);
    auto xConversionResult = convert<IDLUnrestrictedDouble>(*lexicalGlobalObject, argument1.value());
    if (UNLIKELY(xConversionResult.hasException(throwScope)))
       return encodedJSValue();
    EnsureStillAliveScope argument2 = callFrame->uncheckedArgument(2);
    auto yConversionResult = convert<IDLUnrestrictedDouble>(*lexicalGlobalObject, argument2.value());
    if (UNLIKELY(yConversionResult.hasException(throwScope)))
       return encodedJSValue();
    EnsureStillAliveScope argument3 = callFrame->argument(3);
    auto fillRuleConversionResult = convertOptionalWithDefault<IDLEnumeration<CanvasFillRule>>(*lexicalGlobalObject, argument3.value(), [&]() -> ConversionResult<IDLEnumeration<CanvasFillRule>> { return Converter<IDLEnumeration<CanvasFillRule>>::ReturnType { CanvasFillRule::Nonzero }; }, [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentMustBeEnumError(lexicalGlobalObject, scope, 3, "fillRule"_s, "PaintRenderingContext2D"_s, "isPointInPath"_s, expectedEnumerationValues<CanvasFillRule>()); });
    if (UNLIKELY(fillRuleConversionResult.hasException(throwScope)))
       return encodedJSValue();
    RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLBoolean>(*lexicalGlobalObject, throwScope, impl.isPointInPath(*pathConversionResult.releaseReturnValue(), xConversionResult.releaseReturnValue(), yConversionResult.releaseReturnValue(), fillRuleConversionResult.releaseReturnValue()))));
}

static inline JSC::EncodedJSValue jsPaintRenderingContext2DPrototypeFunction_isPointInPathOverloadDispatcher(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSPaintRenderingContext2D>::ClassParameter castedThis)
{
    auto& vm = JSC::getVM(lexicalGlobalObject);
    auto throwScope = DECLARE_THROW_SCOPE(vm);
    UNUSED_PARAM(throwScope);
    UNUSED_PARAM(callFrame);
    size_t argsCount = std::min<size_t>(4, callFrame->argumentCount());
    if (argsCount == 2) {
        RELEASE_AND_RETURN(throwScope, (jsPaintRenderingContext2DPrototypeFunction_isPointInPath1Body(lexicalGlobalObject, callFrame, castedThis)));
    }
    if (argsCount == 3) {
        JSValue distinguishingArg = callFrame->uncheckedArgument(0);
        if (distinguishingArg.isObject() && asObject(distinguishingArg)->inherits<JSPath2D>())
            RELEASE_AND_RETURN(throwScope, (jsPaintRenderingContext2DPrototypeFunction_isPointInPath2Body(lexicalGlobalObject, callFrame, castedThis)));
        if (distinguishingArg.isNumber())
            RELEASE_AND_RETURN(throwScope, (jsPaintRenderingContext2DPrototypeFunction_isPointInPath1Body(lexicalGlobalObject, callFrame, castedThis)));
        RELEASE_AND_RETURN(throwScope, (jsPaintRenderingContext2DPrototypeFunction_isPointInPath1Body(lexicalGlobalObject, callFrame, castedThis)));
    }
    if (argsCount == 4) {
        RELEASE_AND_RETURN(throwScope, (jsPaintRenderingContext2DPrototypeFunction_isPointInPath2Body(lexicalGlobalObject, callFrame, castedThis)));
    }
    return argsCount < 2 ? throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject)) : throwVMTypeError(lexicalGlobalObject, throwScope);
}

JSC_DEFINE_HOST_FUNCTION(jsPaintRenderingContext2DPrototypeFunction_isPointInPath, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
{
    return IDLOperation<JSPaintRenderingContext2D>::call<jsPaintRenderingContext2DPrototypeFunction_isPointInPathOverloadDispatcher>(*lexicalGlobalObject, *callFrame, "isPointInPath");
}

static inline JSC::EncodedJSValue jsPaintRenderingContext2DPrototypeFunction_isPointInStroke1Body(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSPaintRenderingContext2D>::ClassParameter castedThis)
{
    auto& vm = JSC::getVM(lexicalGlobalObject);
    auto throwScope = DECLARE_THROW_SCOPE(vm);
    UNUSED_PARAM(throwScope);
    UNUSED_PARAM(callFrame);
    auto& impl = castedThis->wrapped();
    EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
    auto xConversionResult = convert<IDLUnrestrictedDouble>(*lexicalGlobalObject, argument0.value());
    if (UNLIKELY(xConversionResult.hasException(throwScope)))
       return encodedJSValue();
    EnsureStillAliveScope argument1 = callFrame->uncheckedArgument(1);
    auto yConversionResult = convert<IDLUnrestrictedDouble>(*lexicalGlobalObject, argument1.value());
    if (UNLIKELY(yConversionResult.hasException(throwScope)))
       return encodedJSValue();
    RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLBoolean>(*lexicalGlobalObject, throwScope, impl.isPointInStroke(xConversionResult.releaseReturnValue(), yConversionResult.releaseReturnValue()))));
}

static inline JSC::EncodedJSValue jsPaintRenderingContext2DPrototypeFunction_isPointInStroke2Body(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSPaintRenderingContext2D>::ClassParameter castedThis)
{
    auto& vm = JSC::getVM(lexicalGlobalObject);
    auto throwScope = DECLARE_THROW_SCOPE(vm);
    UNUSED_PARAM(throwScope);
    UNUSED_PARAM(callFrame);
    auto& impl = castedThis->wrapped();
    EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
    auto pathConversionResult = convert<IDLInterface<Path2D>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "path"_s, "PaintRenderingContext2D"_s, "isPointInStroke"_s, "Path2D"_s); });
    if (UNLIKELY(pathConversionResult.hasException(throwScope)))
       return encodedJSValue();
    EnsureStillAliveScope argument1 = callFrame->uncheckedArgument(1);
    auto xConversionResult = convert<IDLUnrestrictedDouble>(*lexicalGlobalObject, argument1.value());
    if (UNLIKELY(xConversionResult.hasException(throwScope)))
       return encodedJSValue();
    EnsureStillAliveScope argument2 = callFrame->uncheckedArgument(2);
    auto yConversionResult = convert<IDLUnrestrictedDouble>(*lexicalGlobalObject, argument2.value());
    if (UNLIKELY(yConversionResult.hasException(throwScope)))
       return encodedJSValue();
    RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLBoolean>(*lexicalGlobalObject, throwScope, impl.isPointInStroke(*pathConversionResult.releaseReturnValue(), xConversionResult.releaseReturnValue(), yConversionResult.releaseReturnValue()))));
}

static inline JSC::EncodedJSValue jsPaintRenderingContext2DPrototypeFunction_isPointInStrokeOverloadDispatcher(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSPaintRenderingContext2D>::ClassParameter castedThis)
{
    auto& vm = JSC::getVM(lexicalGlobalObject);
    auto throwScope = DECLARE_THROW_SCOPE(vm);
    UNUSED_PARAM(throwScope);
    UNUSED_PARAM(callFrame);
    size_t argsCount = std::min<size_t>(3, callFrame->argumentCount());
    if (argsCount == 2) {
        RELEASE_AND_RETURN(throwScope, (jsPaintRenderingContext2DPrototypeFunction_isPointInStroke1Body(lexicalGlobalObject, callFrame, castedThis)));
    }
    if (argsCount == 3) {
        RELEASE_AND_RETURN(throwScope, (jsPaintRenderingContext2DPrototypeFunction_isPointInStroke2Body(lexicalGlobalObject, callFrame, castedThis)));
    }
    return argsCount < 2 ? throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject)) : throwVMTypeError(lexicalGlobalObject, throwScope);
}

JSC_DEFINE_HOST_FUNCTION(jsPaintRenderingContext2DPrototypeFunction_isPointInStroke, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
{
    return IDLOperation<JSPaintRenderingContext2D>::call<jsPaintRenderingContext2DPrototypeFunction_isPointInStrokeOverloadDispatcher>(*lexicalGlobalObject, *callFrame, "isPointInStroke");
}

static inline JSC::EncodedJSValue jsPaintRenderingContext2DPrototypeFunction_createLinearGradientBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSPaintRenderingContext2D>::ClassParameter castedThis)
{
    auto& vm = JSC::getVM(lexicalGlobalObject);
    auto throwScope = DECLARE_THROW_SCOPE(vm);
    UNUSED_PARAM(throwScope);
    UNUSED_PARAM(callFrame);
    auto& impl = castedThis->wrapped();
    if (UNLIKELY(callFrame->argumentCount() < 4))
        return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
    EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
    auto x0ConversionResult = convert<IDLDouble>(*lexicalGlobalObject, argument0.value());
    if (UNLIKELY(x0ConversionResult.hasException(throwScope)))
       return encodedJSValue();
    EnsureStillAliveScope argument1 = callFrame->uncheckedArgument(1);
    auto y0ConversionResult = convert<IDLDouble>(*lexicalGlobalObject, argument1.value());
    if (UNLIKELY(y0ConversionResult.hasException(throwScope)))
       return encodedJSValue();
    EnsureStillAliveScope argument2 = callFrame->uncheckedArgument(2);
    auto x1ConversionResult = convert<IDLDouble>(*lexicalGlobalObject, argument2.value());
    if (UNLIKELY(x1ConversionResult.hasException(throwScope)))
       return encodedJSValue();
    EnsureStillAliveScope argument3 = callFrame->uncheckedArgument(3);
    auto y1ConversionResult = convert<IDLDouble>(*lexicalGlobalObject, argument3.value());
    if (UNLIKELY(y1ConversionResult.hasException(throwScope)))
       return encodedJSValue();
    RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLInterface<CanvasGradient>>(*lexicalGlobalObject, *castedThis->globalObject(), throwScope, impl.createLinearGradient(x0ConversionResult.releaseReturnValue(), y0ConversionResult.releaseReturnValue(), x1ConversionResult.releaseReturnValue(), y1ConversionResult.releaseReturnValue()))));
}

JSC_DEFINE_HOST_FUNCTION(jsPaintRenderingContext2DPrototypeFunction_createLinearGradient, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
{
    return IDLOperation<JSPaintRenderingContext2D>::call<jsPaintRenderingContext2DPrototypeFunction_createLinearGradientBody>(*lexicalGlobalObject, *callFrame, "createLinearGradient");
}

static inline JSC::EncodedJSValue jsPaintRenderingContext2DPrototypeFunction_createRadialGradientBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSPaintRenderingContext2D>::ClassParameter castedThis)
{
    auto& vm = JSC::getVM(lexicalGlobalObject);
    auto throwScope = DECLARE_THROW_SCOPE(vm);
    UNUSED_PARAM(throwScope);
    UNUSED_PARAM(callFrame);
    auto& impl = castedThis->wrapped();
    if (UNLIKELY(callFrame->argumentCount() < 6))
        return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
    EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
    auto x0ConversionResult = convert<IDLDouble>(*lexicalGlobalObject, argument0.value());
    if (UNLIKELY(x0ConversionResult.hasException(throwScope)))
       return encodedJSValue();
    EnsureStillAliveScope argument1 = callFrame->uncheckedArgument(1);
    auto y0ConversionResult = convert<IDLDouble>(*lexicalGlobalObject, argument1.value());
    if (UNLIKELY(y0ConversionResult.hasException(throwScope)))
       return encodedJSValue();
    EnsureStillAliveScope argument2 = callFrame->uncheckedArgument(2);
    auto r0ConversionResult = convert<IDLDouble>(*lexicalGlobalObject, argument2.value());
    if (UNLIKELY(r0ConversionResult.hasException(throwScope)))
       return encodedJSValue();
    EnsureStillAliveScope argument3 = callFrame->uncheckedArgument(3);
    auto x1ConversionResult = convert<IDLDouble>(*lexicalGlobalObject, argument3.value());
    if (UNLIKELY(x1ConversionResult.hasException(throwScope)))
       return encodedJSValue();
    EnsureStillAliveScope argument4 = callFrame->uncheckedArgument(4);
    auto y1ConversionResult = convert<IDLDouble>(*lexicalGlobalObject, argument4.value());
    if (UNLIKELY(y1ConversionResult.hasException(throwScope)))
       return encodedJSValue();
    EnsureStillAliveScope argument5 = callFrame->uncheckedArgument(5);
    auto r1ConversionResult = convert<IDLDouble>(*lexicalGlobalObject, argument5.value());
    if (UNLIKELY(r1ConversionResult.hasException(throwScope)))
       return encodedJSValue();
    RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLInterface<CanvasGradient>>(*lexicalGlobalObject, *castedThis->globalObject(), throwScope, impl.createRadialGradient(x0ConversionResult.releaseReturnValue(), y0ConversionResult.releaseReturnValue(), r0ConversionResult.releaseReturnValue(), x1ConversionResult.releaseReturnValue(), y1ConversionResult.releaseReturnValue(), r1ConversionResult.releaseReturnValue()))));
}

JSC_DEFINE_HOST_FUNCTION(jsPaintRenderingContext2DPrototypeFunction_createRadialGradient, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
{
    return IDLOperation<JSPaintRenderingContext2D>::call<jsPaintRenderingContext2DPrototypeFunction_createRadialGradientBody>(*lexicalGlobalObject, *callFrame, "createRadialGradient");
}

static inline JSC::EncodedJSValue jsPaintRenderingContext2DPrototypeFunction_createConicGradientBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSPaintRenderingContext2D>::ClassParameter castedThis)
{
    auto& vm = JSC::getVM(lexicalGlobalObject);
    auto throwScope = DECLARE_THROW_SCOPE(vm);
    UNUSED_PARAM(throwScope);
    UNUSED_PARAM(callFrame);
    auto& impl = castedThis->wrapped();
    if (UNLIKELY(callFrame->argumentCount() < 3))
        return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
    EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
    auto angleConversionResult = convert<IDLDouble>(*lexicalGlobalObject, argument0.value());
    if (UNLIKELY(angleConversionResult.hasException(throwScope)))
       return encodedJSValue();
    EnsureStillAliveScope argument1 = callFrame->uncheckedArgument(1);
    auto xConversionResult = convert<IDLDouble>(*lexicalGlobalObject, argument1.value());
    if (UNLIKELY(xConversionResult.hasException(throwScope)))
       return encodedJSValue();
    EnsureStillAliveScope argument2 = callFrame->uncheckedArgument(2);
    auto yConversionResult = convert<IDLDouble>(*lexicalGlobalObject, argument2.value());
    if (UNLIKELY(yConversionResult.hasException(throwScope)))
       return encodedJSValue();
    RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLInterface<CanvasGradient>>(*lexicalGlobalObject, *castedThis->globalObject(), throwScope, impl.createConicGradient(angleConversionResult.releaseReturnValue(), xConversionResult.releaseReturnValue(), yConversionResult.releaseReturnValue()))));
}

JSC_DEFINE_HOST_FUNCTION(jsPaintRenderingContext2DPrototypeFunction_createConicGradient, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
{
    return IDLOperation<JSPaintRenderingContext2D>::call<jsPaintRenderingContext2DPrototypeFunction_createConicGradientBody>(*lexicalGlobalObject, *callFrame, "createConicGradient");
}

static inline JSC::EncodedJSValue jsPaintRenderingContext2DPrototypeFunction_createPatternBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSPaintRenderingContext2D>::ClassParameter castedThis)
{
    auto& vm = JSC::getVM(lexicalGlobalObject);
    auto throwScope = DECLARE_THROW_SCOPE(vm);
    UNUSED_PARAM(throwScope);
    UNUSED_PARAM(callFrame);
    auto& impl = castedThis->wrapped();
    if (UNLIKELY(callFrame->argumentCount() < 2))
        return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
    EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
    auto imageConversionResult = convert<IDLUnion<IDLInterface<HTMLImageElement>, IDLInterface<SVGImageElement>, IDLInterface<HTMLCanvasElement>, IDLInterface<ImageBitmap>, IDLInterface<CSSStyleImageValue>, IDLInterface<OffscreenCanvas>, IDLInterface<HTMLVideoElement>, IDLInterface<WebCodecsVideoFrame>>>(*lexicalGlobalObject, argument0.value());
    if (UNLIKELY(imageConversionResult.hasException(throwScope)))
       return encodedJSValue();
    EnsureStillAliveScope argument1 = callFrame->uncheckedArgument(1);
    auto repetitionConversionResult = convert<IDLLegacyNullToEmptyStringAdaptor<IDLDOMString>>(*lexicalGlobalObject, argument1.value());
    if (UNLIKELY(repetitionConversionResult.hasException(throwScope)))
       return encodedJSValue();
    RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLNullable<IDLInterface<CanvasPattern>>>(*lexicalGlobalObject, *castedThis->globalObject(), throwScope, impl.createPattern(imageConversionResult.releaseReturnValue(), repetitionConversionResult.releaseReturnValue()))));
}

JSC_DEFINE_HOST_FUNCTION(jsPaintRenderingContext2DPrototypeFunction_createPattern, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
{
    return IDLOperation<JSPaintRenderingContext2D>::call<jsPaintRenderingContext2DPrototypeFunction_createPatternBody>(*lexicalGlobalObject, *callFrame, "createPattern");
}

static inline JSC::EncodedJSValue jsPaintRenderingContext2DPrototypeFunction_closePathBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSPaintRenderingContext2D>::ClassParameter castedThis)
{
    auto& vm = JSC::getVM(lexicalGlobalObject);
    auto throwScope = DECLARE_THROW_SCOPE(vm);
    UNUSED_PARAM(throwScope);
    UNUSED_PARAM(callFrame);
    auto& impl = castedThis->wrapped();
    RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.closePath(); })));
}

JSC_DEFINE_HOST_FUNCTION(jsPaintRenderingContext2DPrototypeFunction_closePath, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
{
    return IDLOperation<JSPaintRenderingContext2D>::call<jsPaintRenderingContext2DPrototypeFunction_closePathBody>(*lexicalGlobalObject, *callFrame, "closePath");
}

static inline JSC::EncodedJSValue jsPaintRenderingContext2DPrototypeFunction_moveToBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSPaintRenderingContext2D>::ClassParameter castedThis)
{
    auto& vm = JSC::getVM(lexicalGlobalObject);
    auto throwScope = DECLARE_THROW_SCOPE(vm);
    UNUSED_PARAM(throwScope);
    UNUSED_PARAM(callFrame);
    auto& impl = castedThis->wrapped();
    if (UNLIKELY(callFrame->argumentCount() < 2))
        return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
    EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
    auto xConversionResult = convert<IDLUnrestrictedDouble>(*lexicalGlobalObject, argument0.value());
    if (UNLIKELY(xConversionResult.hasException(throwScope)))
       return encodedJSValue();
    EnsureStillAliveScope argument1 = callFrame->uncheckedArgument(1);
    auto yConversionResult = convert<IDLUnrestrictedDouble>(*lexicalGlobalObject, argument1.value());
    if (UNLIKELY(yConversionResult.hasException(throwScope)))
       return encodedJSValue();
    RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.moveTo(xConversionResult.releaseReturnValue(), yConversionResult.releaseReturnValue()); })));
}

JSC_DEFINE_HOST_FUNCTION(jsPaintRenderingContext2DPrototypeFunction_moveTo, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
{
    return IDLOperation<JSPaintRenderingContext2D>::call<jsPaintRenderingContext2DPrototypeFunction_moveToBody>(*lexicalGlobalObject, *callFrame, "moveTo");
}

static inline JSC::EncodedJSValue jsPaintRenderingContext2DPrototypeFunction_lineToBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSPaintRenderingContext2D>::ClassParameter castedThis)
{
    auto& vm = JSC::getVM(lexicalGlobalObject);
    auto throwScope = DECLARE_THROW_SCOPE(vm);
    UNUSED_PARAM(throwScope);
    UNUSED_PARAM(callFrame);
    auto& impl = castedThis->wrapped();
    if (UNLIKELY(callFrame->argumentCount() < 2))
        return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
    EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
    auto xConversionResult = convert<IDLUnrestrictedDouble>(*lexicalGlobalObject, argument0.value());
    if (UNLIKELY(xConversionResult.hasException(throwScope)))
       return encodedJSValue();
    EnsureStillAliveScope argument1 = callFrame->uncheckedArgument(1);
    auto yConversionResult = convert<IDLUnrestrictedDouble>(*lexicalGlobalObject, argument1.value());
    if (UNLIKELY(yConversionResult.hasException(throwScope)))
       return encodedJSValue();
    RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.lineTo(xConversionResult.releaseReturnValue(), yConversionResult.releaseReturnValue()); })));
}

JSC_DEFINE_HOST_FUNCTION(jsPaintRenderingContext2DPrototypeFunction_lineTo, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
{
    return IDLOperation<JSPaintRenderingContext2D>::call<jsPaintRenderingContext2DPrototypeFunction_lineToBody>(*lexicalGlobalObject, *callFrame, "lineTo");
}

static inline JSC::EncodedJSValue jsPaintRenderingContext2DPrototypeFunction_quadraticCurveToBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSPaintRenderingContext2D>::ClassParameter castedThis)
{
    auto& vm = JSC::getVM(lexicalGlobalObject);
    auto throwScope = DECLARE_THROW_SCOPE(vm);
    UNUSED_PARAM(throwScope);
    UNUSED_PARAM(callFrame);
    auto& impl = castedThis->wrapped();
    if (UNLIKELY(callFrame->argumentCount() < 4))
        return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
    EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
    auto cpxConversionResult = convert<IDLUnrestrictedDouble>(*lexicalGlobalObject, argument0.value());
    if (UNLIKELY(cpxConversionResult.hasException(throwScope)))
       return encodedJSValue();
    EnsureStillAliveScope argument1 = callFrame->uncheckedArgument(1);
    auto cpyConversionResult = convert<IDLUnrestrictedDouble>(*lexicalGlobalObject, argument1.value());
    if (UNLIKELY(cpyConversionResult.hasException(throwScope)))
       return encodedJSValue();
    EnsureStillAliveScope argument2 = callFrame->uncheckedArgument(2);
    auto xConversionResult = convert<IDLUnrestrictedDouble>(*lexicalGlobalObject, argument2.value());
    if (UNLIKELY(xConversionResult.hasException(throwScope)))
       return encodedJSValue();
    EnsureStillAliveScope argument3 = callFrame->uncheckedArgument(3);
    auto yConversionResult = convert<IDLUnrestrictedDouble>(*lexicalGlobalObject, argument3.value());
    if (UNLIKELY(yConversionResult.hasException(throwScope)))
       return encodedJSValue();
    RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.quadraticCurveTo(cpxConversionResult.releaseReturnValue(), cpyConversionResult.releaseReturnValue(), xConversionResult.releaseReturnValue(), yConversionResult.releaseReturnValue()); })));
}

JSC_DEFINE_HOST_FUNCTION(jsPaintRenderingContext2DPrototypeFunction_quadraticCurveTo, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
{
    return IDLOperation<JSPaintRenderingContext2D>::call<jsPaintRenderingContext2DPrototypeFunction_quadraticCurveToBody>(*lexicalGlobalObject, *callFrame, "quadraticCurveTo");
}

static inline JSC::EncodedJSValue jsPaintRenderingContext2DPrototypeFunction_bezierCurveToBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSPaintRenderingContext2D>::ClassParameter castedThis)
{
    auto& vm = JSC::getVM(lexicalGlobalObject);
    auto throwScope = DECLARE_THROW_SCOPE(vm);
    UNUSED_PARAM(throwScope);
    UNUSED_PARAM(callFrame);
    auto& impl = castedThis->wrapped();
    if (UNLIKELY(callFrame->argumentCount() < 6))
        return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
    EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
    auto cp1xConversionResult = convert<IDLUnrestrictedDouble>(*lexicalGlobalObject, argument0.value());
    if (UNLIKELY(cp1xConversionResult.hasException(throwScope)))
       return encodedJSValue();
    EnsureStillAliveScope argument1 = callFrame->uncheckedArgument(1);
    auto cp1yConversionResult = convert<IDLUnrestrictedDouble>(*lexicalGlobalObject, argument1.value());
    if (UNLIKELY(cp1yConversionResult.hasException(throwScope)))
       return encodedJSValue();
    EnsureStillAliveScope argument2 = callFrame->uncheckedArgument(2);
    auto cp2xConversionResult = convert<IDLUnrestrictedDouble>(*lexicalGlobalObject, argument2.value());
    if (UNLIKELY(cp2xConversionResult.hasException(throwScope)))
       return encodedJSValue();
    EnsureStillAliveScope argument3 = callFrame->uncheckedArgument(3);
    auto cp2yConversionResult = convert<IDLUnrestrictedDouble>(*lexicalGlobalObject, argument3.value());
    if (UNLIKELY(cp2yConversionResult.hasException(throwScope)))
       return encodedJSValue();
    EnsureStillAliveScope argument4 = callFrame->uncheckedArgument(4);
    auto xConversionResult = convert<IDLUnrestrictedDouble>(*lexicalGlobalObject, argument4.value());
    if (UNLIKELY(xConversionResult.hasException(throwScope)))
       return encodedJSValue();
    EnsureStillAliveScope argument5 = callFrame->uncheckedArgument(5);
    auto yConversionResult = convert<IDLUnrestrictedDouble>(*lexicalGlobalObject, argument5.value());
    if (UNLIKELY(yConversionResult.hasException(throwScope)))
       return encodedJSValue();
    RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.bezierCurveTo(cp1xConversionResult.releaseReturnValue(), cp1yConversionResult.releaseReturnValue(), cp2xConversionResult.releaseReturnValue(), cp2yConversionResult.releaseReturnValue(), xConversionResult.releaseReturnValue(), yConversionResult.releaseReturnValue()); })));
}

JSC_DEFINE_HOST_FUNCTION(jsPaintRenderingContext2DPrototypeFunction_bezierCurveTo, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
{
    return IDLOperation<JSPaintRenderingContext2D>::call<jsPaintRenderingContext2DPrototypeFunction_bezierCurveToBody>(*lexicalGlobalObject, *callFrame, "bezierCurveTo");
}

static inline JSC::EncodedJSValue jsPaintRenderingContext2DPrototypeFunction_arcToBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSPaintRenderingContext2D>::ClassParameter castedThis)
{
    auto& vm = JSC::getVM(lexicalGlobalObject);
    auto throwScope = DECLARE_THROW_SCOPE(vm);
    UNUSED_PARAM(throwScope);
    UNUSED_PARAM(callFrame);
    auto& impl = castedThis->wrapped();
    if (UNLIKELY(callFrame->argumentCount() < 5))
        return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
    EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
    auto x1ConversionResult = convert<IDLUnrestrictedDouble>(*lexicalGlobalObject, argument0.value());
    if (UNLIKELY(x1ConversionResult.hasException(throwScope)))
       return encodedJSValue();
    EnsureStillAliveScope argument1 = callFrame->uncheckedArgument(1);
    auto y1ConversionResult = convert<IDLUnrestrictedDouble>(*lexicalGlobalObject, argument1.value());
    if (UNLIKELY(y1ConversionResult.hasException(throwScope)))
       return encodedJSValue();
    EnsureStillAliveScope argument2 = callFrame->uncheckedArgument(2);
    auto x2ConversionResult = convert<IDLUnrestrictedDouble>(*lexicalGlobalObject, argument2.value());
    if (UNLIKELY(x2ConversionResult.hasException(throwScope)))
       return encodedJSValue();
    EnsureStillAliveScope argument3 = callFrame->uncheckedArgument(3);
    auto y2ConversionResult = convert<IDLUnrestrictedDouble>(*lexicalGlobalObject, argument3.value());
    if (UNLIKELY(y2ConversionResult.hasException(throwScope)))
       return encodedJSValue();
    EnsureStillAliveScope argument4 = callFrame->uncheckedArgument(4);
    auto radiusConversionResult = convert<IDLUnrestrictedDouble>(*lexicalGlobalObject, argument4.value());
    if (UNLIKELY(radiusConversionResult.hasException(throwScope)))
       return encodedJSValue();
    RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.arcTo(x1ConversionResult.releaseReturnValue(), y1ConversionResult.releaseReturnValue(), x2ConversionResult.releaseReturnValue(), y2ConversionResult.releaseReturnValue(), radiusConversionResult.releaseReturnValue()); })));
}

JSC_DEFINE_HOST_FUNCTION(jsPaintRenderingContext2DPrototypeFunction_arcTo, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
{
    return IDLOperation<JSPaintRenderingContext2D>::call<jsPaintRenderingContext2DPrototypeFunction_arcToBody>(*lexicalGlobalObject, *callFrame, "arcTo");
}

static inline JSC::EncodedJSValue jsPaintRenderingContext2DPrototypeFunction_rectBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSPaintRenderingContext2D>::ClassParameter castedThis)
{
    auto& vm = JSC::getVM(lexicalGlobalObject);
    auto throwScope = DECLARE_THROW_SCOPE(vm);
    UNUSED_PARAM(throwScope);
    UNUSED_PARAM(callFrame);
    auto& impl = castedThis->wrapped();
    if (UNLIKELY(callFrame->argumentCount() < 4))
        return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
    EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
    auto xConversionResult = convert<IDLUnrestrictedDouble>(*lexicalGlobalObject, argument0.value());
    if (UNLIKELY(xConversionResult.hasException(throwScope)))
       return encodedJSValue();
    EnsureStillAliveScope argument1 = callFrame->uncheckedArgument(1);
    auto yConversionResult = convert<IDLUnrestrictedDouble>(*lexicalGlobalObject, argument1.value());
    if (UNLIKELY(yConversionResult.hasException(throwScope)))
       return encodedJSValue();
    EnsureStillAliveScope argument2 = callFrame->uncheckedArgument(2);
    auto wConversionResult = convert<IDLUnrestrictedDouble>(*lexicalGlobalObject, argument2.value());
    if (UNLIKELY(wConversionResult.hasException(throwScope)))
       return encodedJSValue();
    EnsureStillAliveScope argument3 = callFrame->uncheckedArgument(3);
    auto hConversionResult = convert<IDLUnrestrictedDouble>(*lexicalGlobalObject, argument3.value());
    if (UNLIKELY(hConversionResult.hasException(throwScope)))
       return encodedJSValue();
    RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.rect(xConversionResult.releaseReturnValue(), yConversionResult.releaseReturnValue(), wConversionResult.releaseReturnValue(), hConversionResult.releaseReturnValue()); })));
}

JSC_DEFINE_HOST_FUNCTION(jsPaintRenderingContext2DPrototypeFunction_rect, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
{
    return IDLOperation<JSPaintRenderingContext2D>::call<jsPaintRenderingContext2DPrototypeFunction_rectBody>(*lexicalGlobalObject, *callFrame, "rect");
}

static inline JSC::EncodedJSValue jsPaintRenderingContext2DPrototypeFunction_roundRect1Body(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSPaintRenderingContext2D>::ClassParameter castedThis)
{
    auto& vm = JSC::getVM(lexicalGlobalObject);
    auto throwScope = DECLARE_THROW_SCOPE(vm);
    UNUSED_PARAM(throwScope);
    UNUSED_PARAM(callFrame);
    auto& impl = castedThis->wrapped();
    EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
    auto xConversionResult = convert<IDLUnrestrictedDouble>(*lexicalGlobalObject, argument0.value());
    if (UNLIKELY(xConversionResult.hasException(throwScope)))
       return encodedJSValue();
    EnsureStillAliveScope argument1 = callFrame->uncheckedArgument(1);
    auto yConversionResult = convert<IDLUnrestrictedDouble>(*lexicalGlobalObject, argument1.value());
    if (UNLIKELY(yConversionResult.hasException(throwScope)))
       return encodedJSValue();
    EnsureStillAliveScope argument2 = callFrame->uncheckedArgument(2);
    auto wConversionResult = convert<IDLUnrestrictedDouble>(*lexicalGlobalObject, argument2.value());
    if (UNLIKELY(wConversionResult.hasException(throwScope)))
       return encodedJSValue();
    EnsureStillAliveScope argument3 = callFrame->uncheckedArgument(3);
    auto hConversionResult = convert<IDLUnrestrictedDouble>(*lexicalGlobalObject, argument3.value());
    if (UNLIKELY(hConversionResult.hasException(throwScope)))
       return encodedJSValue();
    EnsureStillAliveScope argument4 = callFrame->uncheckedArgument(4);
    auto radiiConversionResult = convert<IDLSequence<IDLUnion<IDLUnrestrictedDouble, IDLDictionary<DOMPointInit>>>>(*lexicalGlobalObject, argument4.value());
    if (UNLIKELY(radiiConversionResult.hasException(throwScope)))
       return encodedJSValue();
    RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.roundRect(xConversionResult.releaseReturnValue(), yConversionResult.releaseReturnValue(), wConversionResult.releaseReturnValue(), hConversionResult.releaseReturnValue(), radiiConversionResult.releaseReturnValue()); })));
}

static inline JSC::EncodedJSValue jsPaintRenderingContext2DPrototypeFunction_roundRect2Body(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSPaintRenderingContext2D>::ClassParameter castedThis)
{
    auto& vm = JSC::getVM(lexicalGlobalObject);
    auto throwScope = DECLARE_THROW_SCOPE(vm);
    UNUSED_PARAM(throwScope);
    UNUSED_PARAM(callFrame);
    auto& impl = castedThis->wrapped();
    EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
    auto xConversionResult = convert<IDLUnrestrictedDouble>(*lexicalGlobalObject, argument0.value());
    if (UNLIKELY(xConversionResult.hasException(throwScope)))
       return encodedJSValue();
    EnsureStillAliveScope argument1 = callFrame->uncheckedArgument(1);
    auto yConversionResult = convert<IDLUnrestrictedDouble>(*lexicalGlobalObject, argument1.value());
    if (UNLIKELY(yConversionResult.hasException(throwScope)))
       return encodedJSValue();
    EnsureStillAliveScope argument2 = callFrame->uncheckedArgument(2);
    auto wConversionResult = convert<IDLUnrestrictedDouble>(*lexicalGlobalObject, argument2.value());
    if (UNLIKELY(wConversionResult.hasException(throwScope)))
       return encodedJSValue();
    EnsureStillAliveScope argument3 = callFrame->uncheckedArgument(3);
    auto hConversionResult = convert<IDLUnrestrictedDouble>(*lexicalGlobalObject, argument3.value());
    if (UNLIKELY(hConversionResult.hasException(throwScope)))
       return encodedJSValue();
    EnsureStillAliveScope argument4 = callFrame->uncheckedArgument(4);
    auto radiiConversionResult = convert<IDLUnion<IDLUnrestrictedDouble, IDLDictionary<DOMPointInit>>>(*lexicalGlobalObject, argument4.value());
    if (UNLIKELY(radiiConversionResult.hasException(throwScope)))
       return encodedJSValue();
    RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.roundRect(xConversionResult.releaseReturnValue(), yConversionResult.releaseReturnValue(), wConversionResult.releaseReturnValue(), hConversionResult.releaseReturnValue(), radiiConversionResult.releaseReturnValue()); })));
}

static inline JSC::EncodedJSValue jsPaintRenderingContext2DPrototypeFunction_roundRectOverloadDispatcher(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSPaintRenderingContext2D>::ClassParameter castedThis)
{
    auto& vm = JSC::getVM(lexicalGlobalObject);
    auto throwScope = DECLARE_THROW_SCOPE(vm);
    UNUSED_PARAM(throwScope);
    UNUSED_PARAM(callFrame);
    size_t argsCount = std::min<size_t>(5, callFrame->argumentCount());
    if (argsCount == 5) {
        JSValue distinguishingArg = callFrame->uncheckedArgument(4);
        if (distinguishingArg.isUndefinedOrNull())
            RELEASE_AND_RETURN(throwScope, (jsPaintRenderingContext2DPrototypeFunction_roundRect2Body(lexicalGlobalObject, callFrame, castedThis)));
        {
            bool success = hasIteratorMethod(lexicalGlobalObject, distinguishingArg);
            RETURN_IF_EXCEPTION(throwScope, { });
            if (success)
                RELEASE_AND_RETURN(throwScope, (jsPaintRenderingContext2DPrototypeFunction_roundRect1Body(lexicalGlobalObject, callFrame, castedThis)));
        }
        if (distinguishingArg.isObject())
            RELEASE_AND_RETURN(throwScope, (jsPaintRenderingContext2DPrototypeFunction_roundRect2Body(lexicalGlobalObject, callFrame, castedThis)));
        if (distinguishingArg.isNumber())
            RELEASE_AND_RETURN(throwScope, (jsPaintRenderingContext2DPrototypeFunction_roundRect2Body(lexicalGlobalObject, callFrame, castedThis)));
        RELEASE_AND_RETURN(throwScope, (jsPaintRenderingContext2DPrototypeFunction_roundRect2Body(lexicalGlobalObject, callFrame, castedThis)));
    }
    return argsCount < 5 ? throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject)) : throwVMTypeError(lexicalGlobalObject, throwScope);
}

JSC_DEFINE_HOST_FUNCTION(jsPaintRenderingContext2DPrototypeFunction_roundRect, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
{
    return IDLOperation<JSPaintRenderingContext2D>::call<jsPaintRenderingContext2DPrototypeFunction_roundRectOverloadDispatcher>(*lexicalGlobalObject, *callFrame, "roundRect");
}

static inline JSC::EncodedJSValue jsPaintRenderingContext2DPrototypeFunction_arcBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSPaintRenderingContext2D>::ClassParameter castedThis)
{
    auto& vm = JSC::getVM(lexicalGlobalObject);
    auto throwScope = DECLARE_THROW_SCOPE(vm);
    UNUSED_PARAM(throwScope);
    UNUSED_PARAM(callFrame);
    auto& impl = castedThis->wrapped();
    if (UNLIKELY(callFrame->argumentCount() < 5))
        return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
    EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
    auto xConversionResult = convert<IDLUnrestrictedDouble>(*lexicalGlobalObject, argument0.value());
    if (UNLIKELY(xConversionResult.hasException(throwScope)))
       return encodedJSValue();
    EnsureStillAliveScope argument1 = callFrame->uncheckedArgument(1);
    auto yConversionResult = convert<IDLUnrestrictedDouble>(*lexicalGlobalObject, argument1.value());
    if (UNLIKELY(yConversionResult.hasException(throwScope)))
       return encodedJSValue();
    EnsureStillAliveScope argument2 = callFrame->uncheckedArgument(2);
    auto radiusConversionResult = convert<IDLUnrestrictedDouble>(*lexicalGlobalObject, argument2.value());
    if (UNLIKELY(radiusConversionResult.hasException(throwScope)))
       return encodedJSValue();
    EnsureStillAliveScope argument3 = callFrame->uncheckedArgument(3);
    auto startAngleConversionResult = convert<IDLUnrestrictedDouble>(*lexicalGlobalObject, argument3.value());
    if (UNLIKELY(startAngleConversionResult.hasException(throwScope)))
       return encodedJSValue();
    EnsureStillAliveScope argument4 = callFrame->uncheckedArgument(4);
    auto endAngleConversionResult = convert<IDLUnrestrictedDouble>(*lexicalGlobalObject, argument4.value());
    if (UNLIKELY(endAngleConversionResult.hasException(throwScope)))
       return encodedJSValue();
    EnsureStillAliveScope argument5 = callFrame->argument(5);
    auto anticlockwiseConversionResult = convert<IDLBoolean>(*lexicalGlobalObject, argument5.value());
    if (UNLIKELY(anticlockwiseConversionResult.hasException(throwScope)))
       return encodedJSValue();
    RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.arc(xConversionResult.releaseReturnValue(), yConversionResult.releaseReturnValue(), radiusConversionResult.releaseReturnValue(), startAngleConversionResult.releaseReturnValue(), endAngleConversionResult.releaseReturnValue(), anticlockwiseConversionResult.releaseReturnValue()); })));
}

JSC_DEFINE_HOST_FUNCTION(jsPaintRenderingContext2DPrototypeFunction_arc, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
{
    return IDLOperation<JSPaintRenderingContext2D>::call<jsPaintRenderingContext2DPrototypeFunction_arcBody>(*lexicalGlobalObject, *callFrame, "arc");
}

static inline JSC::EncodedJSValue jsPaintRenderingContext2DPrototypeFunction_ellipseBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSPaintRenderingContext2D>::ClassParameter castedThis)
{
    auto& vm = JSC::getVM(lexicalGlobalObject);
    auto throwScope = DECLARE_THROW_SCOPE(vm);
    UNUSED_PARAM(throwScope);
    UNUSED_PARAM(callFrame);
    auto& impl = castedThis->wrapped();
    if (UNLIKELY(callFrame->argumentCount() < 7))
        return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
    EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
    auto xConversionResult = convert<IDLUnrestrictedDouble>(*lexicalGlobalObject, argument0.value());
    if (UNLIKELY(xConversionResult.hasException(throwScope)))
       return encodedJSValue();
    EnsureStillAliveScope argument1 = callFrame->uncheckedArgument(1);
    auto yConversionResult = convert<IDLUnrestrictedDouble>(*lexicalGlobalObject, argument1.value());
    if (UNLIKELY(yConversionResult.hasException(throwScope)))
       return encodedJSValue();
    EnsureStillAliveScope argument2 = callFrame->uncheckedArgument(2);
    auto radiusXConversionResult = convert<IDLUnrestrictedDouble>(*lexicalGlobalObject, argument2.value());
    if (UNLIKELY(radiusXConversionResult.hasException(throwScope)))
       return encodedJSValue();
    EnsureStillAliveScope argument3 = callFrame->uncheckedArgument(3);
    auto radiusYConversionResult = convert<IDLUnrestrictedDouble>(*lexicalGlobalObject, argument3.value());
    if (UNLIKELY(radiusYConversionResult.hasException(throwScope)))
       return encodedJSValue();
    EnsureStillAliveScope argument4 = callFrame->uncheckedArgument(4);
    auto rotationConversionResult = convert<IDLUnrestrictedDouble>(*lexicalGlobalObject, argument4.value());
    if (UNLIKELY(rotationConversionResult.hasException(throwScope)))
       return encodedJSValue();
    EnsureStillAliveScope argument5 = callFrame->uncheckedArgument(5);
    auto startAngleConversionResult = convert<IDLUnrestrictedDouble>(*lexicalGlobalObject, argument5.value());
    if (UNLIKELY(startAngleConversionResult.hasException(throwScope)))
       return encodedJSValue();
    EnsureStillAliveScope argument6 = callFrame->uncheckedArgument(6);
    auto endAngleConversionResult = convert<IDLUnrestrictedDouble>(*lexicalGlobalObject, argument6.value());
    if (UNLIKELY(endAngleConversionResult.hasException(throwScope)))
       return encodedJSValue();
    EnsureStillAliveScope argument7 = callFrame->argument(7);
    auto anticlockwiseConversionResult = convert<IDLBoolean>(*lexicalGlobalObject, argument7.value());
    if (UNLIKELY(anticlockwiseConversionResult.hasException(throwScope)))
       return encodedJSValue();
    RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.ellipse(xConversionResult.releaseReturnValue(), yConversionResult.releaseReturnValue(), radiusXConversionResult.releaseReturnValue(), radiusYConversionResult.releaseReturnValue(), rotationConversionResult.releaseReturnValue(), startAngleConversionResult.releaseReturnValue(), endAngleConversionResult.releaseReturnValue(), anticlockwiseConversionResult.releaseReturnValue()); })));
}

JSC_DEFINE_HOST_FUNCTION(jsPaintRenderingContext2DPrototypeFunction_ellipse, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
{
    return IDLOperation<JSPaintRenderingContext2D>::call<jsPaintRenderingContext2DPrototypeFunction_ellipseBody>(*lexicalGlobalObject, *callFrame, "ellipse");
}

static inline JSC::EncodedJSValue jsPaintRenderingContext2DPrototypeFunction_setLineDashBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSPaintRenderingContext2D>::ClassParameter castedThis)
{
    auto& vm = JSC::getVM(lexicalGlobalObject);
    auto throwScope = DECLARE_THROW_SCOPE(vm);
    UNUSED_PARAM(throwScope);
    UNUSED_PARAM(callFrame);
    auto& impl = castedThis->wrapped();
    if (UNLIKELY(callFrame->argumentCount() < 1))
        return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
    EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
    auto segmentsConversionResult = convert<IDLSequence<IDLUnrestrictedDouble>>(*lexicalGlobalObject, argument0.value());
    if (UNLIKELY(segmentsConversionResult.hasException(throwScope)))
       return encodedJSValue();
    RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.setLineDash(segmentsConversionResult.releaseReturnValue()); })));
}

JSC_DEFINE_HOST_FUNCTION(jsPaintRenderingContext2DPrototypeFunction_setLineDash, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
{
    return IDLOperation<JSPaintRenderingContext2D>::call<jsPaintRenderingContext2DPrototypeFunction_setLineDashBody>(*lexicalGlobalObject, *callFrame, "setLineDash");
}

static inline JSC::EncodedJSValue jsPaintRenderingContext2DPrototypeFunction_getLineDashBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSPaintRenderingContext2D>::ClassParameter castedThis)
{
    auto& vm = JSC::getVM(lexicalGlobalObject);
    auto throwScope = DECLARE_THROW_SCOPE(vm);
    UNUSED_PARAM(throwScope);
    UNUSED_PARAM(callFrame);
    auto& impl = castedThis->wrapped();
    RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLSequence<IDLUnrestrictedDouble>>(*lexicalGlobalObject, *castedThis->globalObject(), throwScope, impl.getLineDash())));
}

JSC_DEFINE_HOST_FUNCTION(jsPaintRenderingContext2DPrototypeFunction_getLineDash, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
{
    return IDLOperation<JSPaintRenderingContext2D>::call<jsPaintRenderingContext2DPrototypeFunction_getLineDashBody>(*lexicalGlobalObject, *callFrame, "getLineDash");
}

static inline JSC::EncodedJSValue jsPaintRenderingContext2DPrototypeFunction_clearRectBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSPaintRenderingContext2D>::ClassParameter castedThis)
{
    auto& vm = JSC::getVM(lexicalGlobalObject);
    auto throwScope = DECLARE_THROW_SCOPE(vm);
    UNUSED_PARAM(throwScope);
    UNUSED_PARAM(callFrame);
    auto& impl = castedThis->wrapped();
    if (UNLIKELY(callFrame->argumentCount() < 4))
        return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
    EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
    auto xConversionResult = convert<IDLUnrestrictedDouble>(*lexicalGlobalObject, argument0.value());
    if (UNLIKELY(xConversionResult.hasException(throwScope)))
       return encodedJSValue();
    EnsureStillAliveScope argument1 = callFrame->uncheckedArgument(1);
    auto yConversionResult = convert<IDLUnrestrictedDouble>(*lexicalGlobalObject, argument1.value());
    if (UNLIKELY(yConversionResult.hasException(throwScope)))
       return encodedJSValue();
    EnsureStillAliveScope argument2 = callFrame->uncheckedArgument(2);
    auto wConversionResult = convert<IDLUnrestrictedDouble>(*lexicalGlobalObject, argument2.value());
    if (UNLIKELY(wConversionResult.hasException(throwScope)))
       return encodedJSValue();
    EnsureStillAliveScope argument3 = callFrame->uncheckedArgument(3);
    auto hConversionResult = convert<IDLUnrestrictedDouble>(*lexicalGlobalObject, argument3.value());
    if (UNLIKELY(hConversionResult.hasException(throwScope)))
       return encodedJSValue();
    RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.clearRect(xConversionResult.releaseReturnValue(), yConversionResult.releaseReturnValue(), wConversionResult.releaseReturnValue(), hConversionResult.releaseReturnValue()); })));
}

JSC_DEFINE_HOST_FUNCTION(jsPaintRenderingContext2DPrototypeFunction_clearRect, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
{
    return IDLOperation<JSPaintRenderingContext2D>::call<jsPaintRenderingContext2DPrototypeFunction_clearRectBody>(*lexicalGlobalObject, *callFrame, "clearRect");
}

static inline JSC::EncodedJSValue jsPaintRenderingContext2DPrototypeFunction_fillRectBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSPaintRenderingContext2D>::ClassParameter castedThis)
{
    auto& vm = JSC::getVM(lexicalGlobalObject);
    auto throwScope = DECLARE_THROW_SCOPE(vm);
    UNUSED_PARAM(throwScope);
    UNUSED_PARAM(callFrame);
    auto& impl = castedThis->wrapped();
    if (UNLIKELY(callFrame->argumentCount() < 4))
        return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
    EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
    auto xConversionResult = convert<IDLUnrestrictedDouble>(*lexicalGlobalObject, argument0.value());
    if (UNLIKELY(xConversionResult.hasException(throwScope)))
       return encodedJSValue();
    EnsureStillAliveScope argument1 = callFrame->uncheckedArgument(1);
    auto yConversionResult = convert<IDLUnrestrictedDouble>(*lexicalGlobalObject, argument1.value());
    if (UNLIKELY(yConversionResult.hasException(throwScope)))
       return encodedJSValue();
    EnsureStillAliveScope argument2 = callFrame->uncheckedArgument(2);
    auto wConversionResult = convert<IDLUnrestrictedDouble>(*lexicalGlobalObject, argument2.value());
    if (UNLIKELY(wConversionResult.hasException(throwScope)))
       return encodedJSValue();
    EnsureStillAliveScope argument3 = callFrame->uncheckedArgument(3);
    auto hConversionResult = convert<IDLUnrestrictedDouble>(*lexicalGlobalObject, argument3.value());
    if (UNLIKELY(hConversionResult.hasException(throwScope)))
       return encodedJSValue();
    RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.fillRect(xConversionResult.releaseReturnValue(), yConversionResult.releaseReturnValue(), wConversionResult.releaseReturnValue(), hConversionResult.releaseReturnValue()); })));
}

JSC_DEFINE_HOST_FUNCTION(jsPaintRenderingContext2DPrototypeFunction_fillRect, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
{
    return IDLOperation<JSPaintRenderingContext2D>::call<jsPaintRenderingContext2DPrototypeFunction_fillRectBody>(*lexicalGlobalObject, *callFrame, "fillRect");
}

static inline JSC::EncodedJSValue jsPaintRenderingContext2DPrototypeFunction_strokeRectBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSPaintRenderingContext2D>::ClassParameter castedThis)
{
    auto& vm = JSC::getVM(lexicalGlobalObject);
    auto throwScope = DECLARE_THROW_SCOPE(vm);
    UNUSED_PARAM(throwScope);
    UNUSED_PARAM(callFrame);
    auto& impl = castedThis->wrapped();
    if (UNLIKELY(callFrame->argumentCount() < 4))
        return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
    EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
    auto xConversionResult = convert<IDLUnrestrictedDouble>(*lexicalGlobalObject, argument0.value());
    if (UNLIKELY(xConversionResult.hasException(throwScope)))
       return encodedJSValue();
    EnsureStillAliveScope argument1 = callFrame->uncheckedArgument(1);
    auto yConversionResult = convert<IDLUnrestrictedDouble>(*lexicalGlobalObject, argument1.value());
    if (UNLIKELY(yConversionResult.hasException(throwScope)))
       return encodedJSValue();
    EnsureStillAliveScope argument2 = callFrame->uncheckedArgument(2);
    auto wConversionResult = convert<IDLUnrestrictedDouble>(*lexicalGlobalObject, argument2.value());
    if (UNLIKELY(wConversionResult.hasException(throwScope)))
       return encodedJSValue();
    EnsureStillAliveScope argument3 = callFrame->uncheckedArgument(3);
    auto hConversionResult = convert<IDLUnrestrictedDouble>(*lexicalGlobalObject, argument3.value());
    if (UNLIKELY(hConversionResult.hasException(throwScope)))
       return encodedJSValue();
    RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.strokeRect(xConversionResult.releaseReturnValue(), yConversionResult.releaseReturnValue(), wConversionResult.releaseReturnValue(), hConversionResult.releaseReturnValue()); })));
}

JSC_DEFINE_HOST_FUNCTION(jsPaintRenderingContext2DPrototypeFunction_strokeRect, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
{
    return IDLOperation<JSPaintRenderingContext2D>::call<jsPaintRenderingContext2DPrototypeFunction_strokeRectBody>(*lexicalGlobalObject, *callFrame, "strokeRect");
}

static inline JSC::EncodedJSValue jsPaintRenderingContext2DPrototypeFunction_saveBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSPaintRenderingContext2D>::ClassParameter castedThis)
{
    auto& vm = JSC::getVM(lexicalGlobalObject);
    auto throwScope = DECLARE_THROW_SCOPE(vm);
    UNUSED_PARAM(throwScope);
    UNUSED_PARAM(callFrame);
    auto& impl = castedThis->wrapped();
    RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.save(); })));
}

JSC_DEFINE_HOST_FUNCTION(jsPaintRenderingContext2DPrototypeFunction_save, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
{
    return IDLOperation<JSPaintRenderingContext2D>::call<jsPaintRenderingContext2DPrototypeFunction_saveBody>(*lexicalGlobalObject, *callFrame, "save");
}

static inline JSC::EncodedJSValue jsPaintRenderingContext2DPrototypeFunction_restoreBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSPaintRenderingContext2D>::ClassParameter castedThis)
{
    auto& vm = JSC::getVM(lexicalGlobalObject);
    auto throwScope = DECLARE_THROW_SCOPE(vm);
    UNUSED_PARAM(throwScope);
    UNUSED_PARAM(callFrame);
    auto& impl = castedThis->wrapped();
    RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.restore(); })));
}

JSC_DEFINE_HOST_FUNCTION(jsPaintRenderingContext2DPrototypeFunction_restore, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
{
    return IDLOperation<JSPaintRenderingContext2D>::call<jsPaintRenderingContext2DPrototypeFunction_restoreBody>(*lexicalGlobalObject, *callFrame, "restore");
}

static inline JSC::EncodedJSValue jsPaintRenderingContext2DPrototypeFunction_resetBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSPaintRenderingContext2D>::ClassParameter castedThis)
{
    auto& vm = JSC::getVM(lexicalGlobalObject);
    auto throwScope = DECLARE_THROW_SCOPE(vm);
    UNUSED_PARAM(throwScope);
    UNUSED_PARAM(callFrame);
    auto& impl = castedThis->wrapped();
    RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.reset(); })));
}

JSC_DEFINE_HOST_FUNCTION(jsPaintRenderingContext2DPrototypeFunction_reset, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
{
    return IDLOperation<JSPaintRenderingContext2D>::call<jsPaintRenderingContext2DPrototypeFunction_resetBody>(*lexicalGlobalObject, *callFrame, "reset");
}

static inline JSC::EncodedJSValue jsPaintRenderingContext2DPrototypeFunction_scaleBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSPaintRenderingContext2D>::ClassParameter castedThis)
{
    auto& vm = JSC::getVM(lexicalGlobalObject);
    auto throwScope = DECLARE_THROW_SCOPE(vm);
    UNUSED_PARAM(throwScope);
    UNUSED_PARAM(callFrame);
    auto& impl = castedThis->wrapped();
    if (UNLIKELY(callFrame->argumentCount() < 2))
        return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
    EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
    auto xConversionResult = convert<IDLUnrestrictedDouble>(*lexicalGlobalObject, argument0.value());
    if (UNLIKELY(xConversionResult.hasException(throwScope)))
       return encodedJSValue();
    EnsureStillAliveScope argument1 = callFrame->uncheckedArgument(1);
    auto yConversionResult = convert<IDLUnrestrictedDouble>(*lexicalGlobalObject, argument1.value());
    if (UNLIKELY(yConversionResult.hasException(throwScope)))
       return encodedJSValue();
    RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.scale(xConversionResult.releaseReturnValue(), yConversionResult.releaseReturnValue()); })));
}

JSC_DEFINE_HOST_FUNCTION(jsPaintRenderingContext2DPrototypeFunction_scale, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
{
    return IDLOperation<JSPaintRenderingContext2D>::call<jsPaintRenderingContext2DPrototypeFunction_scaleBody>(*lexicalGlobalObject, *callFrame, "scale");
}

static inline JSC::EncodedJSValue jsPaintRenderingContext2DPrototypeFunction_rotateBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSPaintRenderingContext2D>::ClassParameter castedThis)
{
    auto& vm = JSC::getVM(lexicalGlobalObject);
    auto throwScope = DECLARE_THROW_SCOPE(vm);
    UNUSED_PARAM(throwScope);
    UNUSED_PARAM(callFrame);
    auto& impl = castedThis->wrapped();
    if (UNLIKELY(callFrame->argumentCount() < 1))
        return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
    EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
    auto angleConversionResult = convert<IDLUnrestrictedDouble>(*lexicalGlobalObject, argument0.value());
    if (UNLIKELY(angleConversionResult.hasException(throwScope)))
       return encodedJSValue();
    RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.rotate(angleConversionResult.releaseReturnValue()); })));
}

JSC_DEFINE_HOST_FUNCTION(jsPaintRenderingContext2DPrototypeFunction_rotate, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
{
    return IDLOperation<JSPaintRenderingContext2D>::call<jsPaintRenderingContext2DPrototypeFunction_rotateBody>(*lexicalGlobalObject, *callFrame, "rotate");
}

static inline JSC::EncodedJSValue jsPaintRenderingContext2DPrototypeFunction_translateBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSPaintRenderingContext2D>::ClassParameter castedThis)
{
    auto& vm = JSC::getVM(lexicalGlobalObject);
    auto throwScope = DECLARE_THROW_SCOPE(vm);
    UNUSED_PARAM(throwScope);
    UNUSED_PARAM(callFrame);
    auto& impl = castedThis->wrapped();
    if (UNLIKELY(callFrame->argumentCount() < 2))
        return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
    EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
    auto xConversionResult = convert<IDLUnrestrictedDouble>(*lexicalGlobalObject, argument0.value());
    if (UNLIKELY(xConversionResult.hasException(throwScope)))
       return encodedJSValue();
    EnsureStillAliveScope argument1 = callFrame->uncheckedArgument(1);
    auto yConversionResult = convert<IDLUnrestrictedDouble>(*lexicalGlobalObject, argument1.value());
    if (UNLIKELY(yConversionResult.hasException(throwScope)))
       return encodedJSValue();
    RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.translate(xConversionResult.releaseReturnValue(), yConversionResult.releaseReturnValue()); })));
}

JSC_DEFINE_HOST_FUNCTION(jsPaintRenderingContext2DPrototypeFunction_translate, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
{
    return IDLOperation<JSPaintRenderingContext2D>::call<jsPaintRenderingContext2DPrototypeFunction_translateBody>(*lexicalGlobalObject, *callFrame, "translate");
}

static inline JSC::EncodedJSValue jsPaintRenderingContext2DPrototypeFunction_transformBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSPaintRenderingContext2D>::ClassParameter castedThis)
{
    auto& vm = JSC::getVM(lexicalGlobalObject);
    auto throwScope = DECLARE_THROW_SCOPE(vm);
    UNUSED_PARAM(throwScope);
    UNUSED_PARAM(callFrame);
    auto& impl = castedThis->wrapped();
    if (UNLIKELY(callFrame->argumentCount() < 6))
        return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
    EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
    auto aConversionResult = convert<IDLUnrestrictedDouble>(*lexicalGlobalObject, argument0.value());
    if (UNLIKELY(aConversionResult.hasException(throwScope)))
       return encodedJSValue();
    EnsureStillAliveScope argument1 = callFrame->uncheckedArgument(1);
    auto bConversionResult = convert<IDLUnrestrictedDouble>(*lexicalGlobalObject, argument1.value());
    if (UNLIKELY(bConversionResult.hasException(throwScope)))
       return encodedJSValue();
    EnsureStillAliveScope argument2 = callFrame->uncheckedArgument(2);
    auto cConversionResult = convert<IDLUnrestrictedDouble>(*lexicalGlobalObject, argument2.value());
    if (UNLIKELY(cConversionResult.hasException(throwScope)))
       return encodedJSValue();
    EnsureStillAliveScope argument3 = callFrame->uncheckedArgument(3);
    auto dConversionResult = convert<IDLUnrestrictedDouble>(*lexicalGlobalObject, argument3.value());
    if (UNLIKELY(dConversionResult.hasException(throwScope)))
       return encodedJSValue();
    EnsureStillAliveScope argument4 = callFrame->uncheckedArgument(4);
    auto eConversionResult = convert<IDLUnrestrictedDouble>(*lexicalGlobalObject, argument4.value());
    if (UNLIKELY(eConversionResult.hasException(throwScope)))
       return encodedJSValue();
    EnsureStillAliveScope argument5 = callFrame->uncheckedArgument(5);
    auto fConversionResult = convert<IDLUnrestrictedDouble>(*lexicalGlobalObject, argument5.value());
    if (UNLIKELY(fConversionResult.hasException(throwScope)))
       return encodedJSValue();
    RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.transform(aConversionResult.releaseReturnValue(), bConversionResult.releaseReturnValue(), cConversionResult.releaseReturnValue(), dConversionResult.releaseReturnValue(), eConversionResult.releaseReturnValue(), fConversionResult.releaseReturnValue()); })));
}

JSC_DEFINE_HOST_FUNCTION(jsPaintRenderingContext2DPrototypeFunction_transform, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
{
    return IDLOperation<JSPaintRenderingContext2D>::call<jsPaintRenderingContext2DPrototypeFunction_transformBody>(*lexicalGlobalObject, *callFrame, "transform");
}

static inline JSC::EncodedJSValue jsPaintRenderingContext2DPrototypeFunction_getTransformBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSPaintRenderingContext2D>::ClassParameter castedThis)
{
    auto& vm = JSC::getVM(lexicalGlobalObject);
    auto throwScope = DECLARE_THROW_SCOPE(vm);
    UNUSED_PARAM(throwScope);
    UNUSED_PARAM(callFrame);
    auto& impl = castedThis->wrapped();
    RELEASE_AND_RETURN(throwScope, JSValue::encode(toJSNewlyCreated<IDLInterface<DOMMatrix>>(*lexicalGlobalObject, *castedThis->globalObject(), throwScope, impl.getTransform())));
}

JSC_DEFINE_HOST_FUNCTION(jsPaintRenderingContext2DPrototypeFunction_getTransform, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
{
    return IDLOperation<JSPaintRenderingContext2D>::call<jsPaintRenderingContext2DPrototypeFunction_getTransformBody>(*lexicalGlobalObject, *callFrame, "getTransform");
}

static inline JSC::EncodedJSValue jsPaintRenderingContext2DPrototypeFunction_setTransform1Body(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSPaintRenderingContext2D>::ClassParameter castedThis)
{
    auto& vm = JSC::getVM(lexicalGlobalObject);
    auto throwScope = DECLARE_THROW_SCOPE(vm);
    UNUSED_PARAM(throwScope);
    UNUSED_PARAM(callFrame);
    auto& impl = castedThis->wrapped();
    EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
    auto aConversionResult = convert<IDLUnrestrictedDouble>(*lexicalGlobalObject, argument0.value());
    if (UNLIKELY(aConversionResult.hasException(throwScope)))
       return encodedJSValue();
    EnsureStillAliveScope argument1 = callFrame->uncheckedArgument(1);
    auto bConversionResult = convert<IDLUnrestrictedDouble>(*lexicalGlobalObject, argument1.value());
    if (UNLIKELY(bConversionResult.hasException(throwScope)))
       return encodedJSValue();
    EnsureStillAliveScope argument2 = callFrame->uncheckedArgument(2);
    auto cConversionResult = convert<IDLUnrestrictedDouble>(*lexicalGlobalObject, argument2.value());
    if (UNLIKELY(cConversionResult.hasException(throwScope)))
       return encodedJSValue();
    EnsureStillAliveScope argument3 = callFrame->uncheckedArgument(3);
    auto dConversionResult = convert<IDLUnrestrictedDouble>(*lexicalGlobalObject, argument3.value());
    if (UNLIKELY(dConversionResult.hasException(throwScope)))
       return encodedJSValue();
    EnsureStillAliveScope argument4 = callFrame->uncheckedArgument(4);
    auto eConversionResult = convert<IDLUnrestrictedDouble>(*lexicalGlobalObject, argument4.value());
    if (UNLIKELY(eConversionResult.hasException(throwScope)))
       return encodedJSValue();
    EnsureStillAliveScope argument5 = callFrame->uncheckedArgument(5);
    auto fConversionResult = convert<IDLUnrestrictedDouble>(*lexicalGlobalObject, argument5.value());
    if (UNLIKELY(fConversionResult.hasException(throwScope)))
       return encodedJSValue();
    RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.setTransform(aConversionResult.releaseReturnValue(), bConversionResult.releaseReturnValue(), cConversionResult.releaseReturnValue(), dConversionResult.releaseReturnValue(), eConversionResult.releaseReturnValue(), fConversionResult.releaseReturnValue()); })));
}

static inline JSC::EncodedJSValue jsPaintRenderingContext2DPrototypeFunction_setTransform2Body(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSPaintRenderingContext2D>::ClassParameter castedThis)
{
    auto& vm = JSC::getVM(lexicalGlobalObject);
    auto throwScope = DECLARE_THROW_SCOPE(vm);
    UNUSED_PARAM(throwScope);
    UNUSED_PARAM(callFrame);
    auto& impl = castedThis->wrapped();
    EnsureStillAliveScope argument0 = callFrame->argument(0);
    auto transformConversionResult = convert<IDLDictionary<DOMMatrix2DInit>>(*lexicalGlobalObject, argument0.value());
    if (UNLIKELY(transformConversionResult.hasException(throwScope)))
       return encodedJSValue();
    RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.setTransform(transformConversionResult.releaseReturnValue()); })));
}

static inline JSC::EncodedJSValue jsPaintRenderingContext2DPrototypeFunction_setTransformOverloadDispatcher(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSPaintRenderingContext2D>::ClassParameter castedThis)
{
    auto& vm = JSC::getVM(lexicalGlobalObject);
    auto throwScope = DECLARE_THROW_SCOPE(vm);
    UNUSED_PARAM(throwScope);
    UNUSED_PARAM(callFrame);
    size_t argsCount = std::min<size_t>(6, callFrame->argumentCount());
    if (argsCount == 0) {
        RELEASE_AND_RETURN(throwScope, (jsPaintRenderingContext2DPrototypeFunction_setTransform2Body(lexicalGlobalObject, callFrame, castedThis)));
    }
    if (argsCount == 1) {
        RELEASE_AND_RETURN(throwScope, (jsPaintRenderingContext2DPrototypeFunction_setTransform2Body(lexicalGlobalObject, callFrame, castedThis)));
    }
    if (argsCount == 6) {
        RELEASE_AND_RETURN(throwScope, (jsPaintRenderingContext2DPrototypeFunction_setTransform1Body(lexicalGlobalObject, callFrame, castedThis)));
    }
    return throwVMTypeError(lexicalGlobalObject, throwScope);
}

JSC_DEFINE_HOST_FUNCTION(jsPaintRenderingContext2DPrototypeFunction_setTransform, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
{
    return IDLOperation<JSPaintRenderingContext2D>::call<jsPaintRenderingContext2DPrototypeFunction_setTransformOverloadDispatcher>(*lexicalGlobalObject, *callFrame, "setTransform");
}

static inline JSC::EncodedJSValue jsPaintRenderingContext2DPrototypeFunction_resetTransformBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSPaintRenderingContext2D>::ClassParameter castedThis)
{
    auto& vm = JSC::getVM(lexicalGlobalObject);
    auto throwScope = DECLARE_THROW_SCOPE(vm);
    UNUSED_PARAM(throwScope);
    UNUSED_PARAM(callFrame);
    auto& impl = castedThis->wrapped();
    RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.resetTransform(); })));
}

JSC_DEFINE_HOST_FUNCTION(jsPaintRenderingContext2DPrototypeFunction_resetTransform, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
{
    return IDLOperation<JSPaintRenderingContext2D>::call<jsPaintRenderingContext2DPrototypeFunction_resetTransformBody>(*lexicalGlobalObject, *callFrame, "resetTransform");
}

JSC::GCClient::IsoSubspace* JSPaintRenderingContext2D::subspaceForImpl(JSC::VM& vm)
{
    return WebCore::subspaceForImpl<JSPaintRenderingContext2D, UseCustomHeapCellType::No>(vm,
        [] (auto& spaces) { return spaces.m_clientSubspaceForPaintRenderingContext2D.get(); },
        [] (auto& spaces, auto&& space) { spaces.m_clientSubspaceForPaintRenderingContext2D = std::forward<decltype(space)>(space); },
        [] (auto& spaces) { return spaces.m_subspaceForPaintRenderingContext2D.get(); },
        [] (auto& spaces, auto&& space) { spaces.m_subspaceForPaintRenderingContext2D = std::forward<decltype(space)>(space); }
    );
}

template<typename Visitor>
void JSPaintRenderingContext2D::visitChildrenImpl(JSCell* cell, Visitor& visitor)
{
    auto* thisObject = jsCast<JSPaintRenderingContext2D*>(cell);
    ASSERT_GC_OBJECT_INHERITS(thisObject, info());
    Base::visitChildren(thisObject, visitor);
    thisObject->visitAdditionalChildren(visitor);
}

DEFINE_VISIT_CHILDREN(JSPaintRenderingContext2D);

template<typename Visitor>
void JSPaintRenderingContext2D::visitOutputConstraints(JSCell* cell, Visitor& visitor)
{
    auto* thisObject = jsCast<JSPaintRenderingContext2D*>(cell);
    ASSERT_GC_OBJECT_INHERITS(thisObject, info());
    Base::visitOutputConstraints(thisObject, visitor);
    thisObject->visitAdditionalChildren(visitor);
}

template void JSPaintRenderingContext2D::visitOutputConstraints(JSCell*, AbstractSlotVisitor&);
template void JSPaintRenderingContext2D::visitOutputConstraints(JSCell*, SlotVisitor&);
void JSPaintRenderingContext2D::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)
{
    auto* thisObject = jsCast<JSPaintRenderingContext2D*>(cell);
    analyzer.setWrappedObjectForCell(cell, &thisObject->wrapped());
    if (thisObject->scriptExecutionContext())
        analyzer.setLabelForCell(cell, makeString("url "_s, thisObject->scriptExecutionContext()->url().string()));
    Base::analyzeHeap(cell, analyzer);
}

void JSPaintRenderingContext2DOwner::finalize(JSC::Handle<JSC::Unknown> handle, void* context)
{
    auto* jsPaintRenderingContext2D = static_cast<JSPaintRenderingContext2D*>(handle.slot()->asCell());
    auto& world = *static_cast<DOMWrapperWorld*>(context);
    uncacheWrapper(world, jsPaintRenderingContext2D->protectedWrapped().ptr(), jsPaintRenderingContext2D);
}

#if ENABLE(BINDING_INTEGRITY)
#if PLATFORM(WIN)
#pragma warning(disable: 4483)
extern "C" { extern void (*const __identifier("??_7PaintRenderingContext2D@WebCore@@6B@")[])(); }
#else
extern "C" { extern void* _ZTVN7WebCore23PaintRenderingContext2DE[]; }
#endif
template<typename T, typename = std::enable_if_t<std::is_same_v<T, PaintRenderingContext2D>, void>> static inline void verifyVTable(PaintRenderingContext2D* ptr) {
    if constexpr (std::is_polymorphic_v<T>) {
        const void* actualVTablePointer = getVTablePointer<T>(ptr);
#if PLATFORM(WIN)
        void* expectedVTablePointer = __identifier("??_7PaintRenderingContext2D@WebCore@@6B@");
#else
        void* expectedVTablePointer = &_ZTVN7WebCore23PaintRenderingContext2DE[2];
#endif

        // If you hit this assertion you either have a use after free bug, or
        // PaintRenderingContext2D has subclasses. If PaintRenderingContext2D has subclasses that get passed
        // to toJS() we currently require PaintRenderingContext2D you to opt out of binding hardening
        // by adding the SkipVTableValidation attribute to the interface IDL definition
        RELEASE_ASSERT(actualVTablePointer == expectedVTablePointer);
    }
}
#endif
JSC::JSValue toJSNewlyCreated(JSC::JSGlobalObject*, JSDOMGlobalObject* globalObject, Ref<PaintRenderingContext2D>&& impl)
{
#if ENABLE(BINDING_INTEGRITY)
    verifyVTable<PaintRenderingContext2D>(impl.ptr());
#endif
    return createWrapper<PaintRenderingContext2D>(globalObject, WTFMove(impl));
}

JSC::JSValue toJS(JSC::JSGlobalObject* lexicalGlobalObject, JSDOMGlobalObject* globalObject, PaintRenderingContext2D& impl)
{
    return wrap(lexicalGlobalObject, globalObject, impl);
}

PaintRenderingContext2D* JSPaintRenderingContext2D::toWrapped(JSC::VM&, JSC::JSValue value)
{
    if (auto* wrapper = jsDynamicCast<JSPaintRenderingContext2D*>(value))
        return &wrapper->wrapped();
    return nullptr;
}

}
