diff options
| author |  Jarred Sumner <709451+Jarred-Sumner@users.noreply.github.com>
| 2022-06-22 23:21:48 -0700 |
|---|---|---|
| committer | Jarred Sumner <709451+Jarred-Sumner@users.noreply.github.com>
| 2022-06-22 23:21:48 -0700 |
| commit | 729d445b6885f69dd2c6355f38707bd42851c791 (patch) | |
| tree | f87a7c408929ea3f57bbb7ace380cf869da83c0e /src/bun.js/bindings/bindings.cpp | |
| parent | 25f820c6bf1d8ec6d444ef579cc036b8c0607b75 (diff) | |
| download | bun-729d445b6885f69dd2c6355f38707bd42851c791.tar.gz bun-729d445b6885f69dd2c6355f38707bd42851c791.tar.zst bun-729d445b6885f69dd2c6355f38707bd42851c791.zip | |
change the directory structurejarred/rename
Diffstat (limited to 'src/bun.js/bindings/bindings.cpp')
| -rw-r--r-- | src/bun.js/bindings/bindings.cpp | 2874 |
1 files changed, 2874 insertions, 0 deletions
diff --git a/src/bun.js/bindings/bindings.cpp b/src/bun.js/bindings/bindings.cpp new file mode 100644 index 000000000..69d836754 --- /dev/null +++ b/src/bun.js/bindings/bindings.cpp @@ -0,0 +1,2874 @@ +#include "root.h" + +#include "BunClientData.h" +#include "GCDefferalContext.h" + +#include "JavaScriptCore/AggregateError.h" +#include "JavaScriptCore/BytecodeIndex.h" +#include "JavaScriptCore/CodeBlock.h" +#include "JavaScriptCore/Completion.h" +#include "JavaScriptCore/DeferredWorkTimer.h" +#include "JavaScriptCore/ErrorInstance.h" +#include "JavaScriptCore/ExceptionHelpers.h" +#include "JavaScriptCore/ExceptionScope.h" +#include "JavaScriptCore/FunctionConstructor.h" +#include "JavaScriptCore/HeapSnapshotBuilder.h" +#include "JavaScriptCore/Identifier.h" +#include "JavaScriptCore/IteratorOperations.h" +#include "JavaScriptCore/JSArray.h" +#include "JavaScriptCore/JSArrayBuffer.h" +#include "JavaScriptCore/JSArrayInlines.h" + +#include "JavaScriptCore/JSCallbackObject.h" +#include "JavaScriptCore/JSClassRef.h" +#include "JavaScriptCore/JSInternalPromise.h" +#include "JavaScriptCore/JSMap.h" +#include "JavaScriptCore/JSModuleLoader.h" +#include "JavaScriptCore/JSModuleRecord.h" +#include "JavaScriptCore/JSNativeStdFunction.h" +#include "JavaScriptCore/JSONObject.h" +#include "JavaScriptCore/JSObject.h" +#include "JavaScriptCore/JSSet.h" +#include "JavaScriptCore/JSString.h" +#include "JavaScriptCore/Microtask.h" +#include "JavaScriptCore/ObjectConstructor.h" +#include "JavaScriptCore/ParserError.h" +#include "JavaScriptCore/ScriptExecutable.h" +#include "JavaScriptCore/StackFrame.h" +#include "JavaScriptCore/StackVisitor.h" +#include "JavaScriptCore/VM.h" +#include "JavaScriptCore/WasmFaultSignalHandler.h" +#include "JavaScriptCore/Watchdog.h" +#include "ZigGlobalObject.h" +#include "helpers.h" + +#include "wtf/text/ExternalStringImpl.h" +#include "wtf/text/StringCommon.h" +#include "wtf/text/StringImpl.h" +#include "wtf/text/StringView.h" +#include "wtf/text/WTFString.h" + +#include "JSFetchHeaders.h" +#include "FetchHeaders.h" +#include "DOMURL.h" +#include "JSDOMURL.h" + +#include <string_view> +#include <uws/src/App.h> +#include <uws/uSockets/src/internal/internal.h> +#include "IDLTypes.h" +#include "JSDOMBinding.h" +#include "JSDOMConstructor.h" +#include "JSDOMConvertBase.h" +#include "JSDOMConvertBoolean.h" +#include "JSDOMConvertInterface.h" +#include "JSDOMConvertNullable.h" +#include "JSDOMConvertRecord.h" +#include "JSDOMConvertSequences.h" +#include "JSDOMConvertStrings.h" +#include "JSDOMConvertUnion.h" +#include "JSDOMExceptionHandling.h" +#include "JSDOMGlobalObjectInlines.h" +#include "JSDOMIterator.h" +#include "JSDOMOperation.h" +#include "JSDOMWrapperCache.h" + +template<typename UWSResponse> +static void copyToUWS(WebCore::FetchHeaders* headers, UWSResponse* res) +{ + auto iter = headers->createIterator(); + uint32_t i = 0; + unsigned count = 0; + for (auto pair = iter.next(); pair; pair = iter.next()) { + auto name = pair->key; + auto value = pair->value; + res->writeHeader(std::string_view(reinterpret_cast<const char*>(name.characters8()), name.length()), std::string_view(reinterpret_cast<const char*>(value.characters8()), value.length())); + } +} + +template<typename PromiseType, bool isInternal> +static void handlePromise(PromiseType* promise, JSC__JSGlobalObject* globalObject, void* ctx, void (*ArgFn3)(void*, JSC__JSGlobalObject* arg0, JSC__CallFrame* callFrame), void (*ArgFn4)(void*, JSC__JSGlobalObject* arg0, JSC__CallFrame* callFrame)) +{ + + JSC::JSNativeStdFunction* resolverFunction = JSC::JSNativeStdFunction::create( + globalObject->vm(), globalObject, 1, String(), [ctx, ArgFn3](JSC::JSGlobalObject* globalObject, JSC::CallFrame* callFrame) -> const JSC::EncodedJSValue { + ArgFn3(ctx, globalObject, callFrame); + return JSC::JSValue::encode(JSC::jsUndefined()); + }); + JSC::JSNativeStdFunction* rejecterFunction = JSC::JSNativeStdFunction::create( + globalObject->vm(), globalObject, 1, String(), + [ctx, ArgFn4](JSC::JSGlobalObject* globalObject, JSC::CallFrame* callFrame) -> JSC::EncodedJSValue { + ArgFn4(ctx, globalObject, callFrame); + return JSC::JSValue::encode(JSC::jsUndefined()); + }); + + if constexpr (!isInternal) { + promise->performPromiseThen(globalObject, resolverFunction, rejecterFunction, JSC::jsUndefined()); + } else { + promise->then(globalObject, resolverFunction, rejecterFunction); + } +} + +extern "C" { + +void WebCore__FetchHeaders__toUWSResponse(WebCore__FetchHeaders* arg0, bool is_ssl, void* arg2) +{ + if (is_ssl) { + copyToUWS<uWS::HttpResponse<true>>(arg0, reinterpret_cast<uWS::HttpResponse<true>*>(arg2)); + } else { + copyToUWS<uWS::HttpResponse<false>>(arg0, reinterpret_cast<uWS::HttpResponse<false>*>(arg2)); + } +} + +WebCore__FetchHeaders* WebCore__FetchHeaders__createEmpty() +{ + RefPtr<WebCore::FetchHeaders> headers = adoptRef(*new WebCore::FetchHeaders({ WebCore::FetchHeaders::Guard::None, {} })); + return headers.leakRef(); +} +void WebCore__FetchHeaders__append(WebCore__FetchHeaders* headers, const ZigString* arg1, const ZigString* arg2) +{ + headers->append(Zig::toString(*arg1), Zig::toString(*arg2)); +} +WebCore__FetchHeaders* WebCore__FetchHeaders__cast_(JSC__JSValue JSValue0, JSC__VM* vm) +{ + return WebCoreCast<WebCore::JSFetchHeaders, WebCore__FetchHeaders>(JSValue0); +} + +using namespace WebCore; + +WebCore__FetchHeaders* WebCore__FetchHeaders__createFromJS(JSC__JSGlobalObject* lexicalGlobalObject, JSC__JSValue argument0_) +{ + Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject); + EnsureStillAliveScope argument0 = JSC::JSValue::decode(argument0_); + auto throwScope = DECLARE_THROW_SCOPE(lexicalGlobalObject->vm()); + auto init = argument0.value().isUndefined() ? std::optional<Converter<IDLUnion<IDLSequence<IDLSequence<IDLByteString>>, IDLRecord<IDLByteString, IDLByteString>>>::ReturnType>() : std::optional<Converter<IDLUnion<IDLSequence<IDLSequence<IDLByteString>>, IDLRecord<IDLByteString, IDLByteString>>>::ReturnType>(convert<IDLUnion<IDLSequence<IDLSequence<IDLByteString>>, IDLRecord<IDLByteString, IDLByteString>>>(*lexicalGlobalObject, argument0.value())); + RETURN_IF_EXCEPTION(throwScope, nullptr); + RefPtr<WebCore::FetchHeaders> headers = adoptRef(*new WebCore::FetchHeaders({ WebCore::FetchHeaders::Guard::None, {} })); + if (init) + headers->fill(WTFMove(init.value())); + return headers.leakRef(); +} + +JSC__JSValue WebCore__FetchHeaders__toJS(WebCore__FetchHeaders* headers, JSC__JSGlobalObject* lexicalGlobalObject) +{ + Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject); + + return JSC::JSValue::encode(WebCore::toJS(lexicalGlobalObject, globalObject, headers)); +} +JSC__JSValue WebCore__FetchHeaders__clone(WebCore__FetchHeaders* headers, JSC__JSGlobalObject* arg1) +{ + Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(arg1); + auto clone = WebCore::FetchHeaders::create(); + clone->fill(*headers); + return JSC::JSValue::encode(WebCore::toJSNewlyCreated(arg1, globalObject, WTFMove(clone))); +} + +WebCore__FetchHeaders* WebCore__FetchHeaders__cloneThis(WebCore__FetchHeaders* headers) +{ + RefPtr<WebCore::FetchHeaders> clone = adoptRef(*new WebCore::FetchHeaders({ WebCore::FetchHeaders::Guard::None, {} })); + if (headers->size() > 0) { + clone->fill(*headers); + } + + return clone.leakRef(); +} + +void WebCore__FetchHeaders__copyTo(WebCore__FetchHeaders* headers, StringPointer* names, StringPointer* values, unsigned char* buf) +{ + auto iter = headers->createIterator(); + uint32_t i = 0; + unsigned count = 0; + for (auto pair = iter.next(); pair; pair = iter.next()) { + auto name = pair->key; + auto value = pair->value; + names[count] = { i, name.length() }; + memcpy(&buf[i], name.characters8(), name.length()); + i += name.length(); + values[count++] = { i, value.length() }; + memcpy(&buf[i], value.characters8(), value.length()); + i += value.length(); + } +} +void WebCore__FetchHeaders__count(WebCore__FetchHeaders* headers, uint32_t* count, uint32_t* buf_len) +{ + auto iter = headers->createIterator(); + uint32_t i = 0; + for (auto pair = iter.next(); pair; pair = iter.next()) { + i += pair->key.length(); + i += pair->value.length(); + } + + *count = headers->size(); + *buf_len = i; +} +typedef struct PicoHTTPHeader { + unsigned const char* name; + size_t name_len; + unsigned const char* value; + size_t value_len; +} PicoHTTPHeader; + +typedef struct PicoHTTPHeaders { + const PicoHTTPHeader* ptr; + size_t len; +} PicoHTTPHeaders; +WebCore::FetchHeaders* WebCore__FetchHeaders__createFromPicoHeaders_(JSC__JSGlobalObject* arg0, const void* arg1) +{ + PicoHTTPHeaders pico_headers = *reinterpret_cast<const PicoHTTPHeaders*>(arg1); + Vector<KeyValuePair<String, String>> pairs; + pairs.reserveCapacity(pico_headers.len); + for (size_t i = 0; i < pico_headers.len; i++) { + WTF::String name = WTF::String(pico_headers.ptr[i].name, pico_headers.ptr[i].name_len); + WTF::String value = WTF::String(pico_headers.ptr[i].value, pico_headers.ptr[i].value_len); + pairs.uncheckedAppend(KeyValuePair<String, String>(name, value)); + } + + RefPtr<WebCore::FetchHeaders> headers = adoptRef(*new WebCore::FetchHeaders({ WebCore::FetchHeaders::Guard::None, {} })); + headers->fill(WebCore::FetchHeaders::Init(WTFMove(pairs))); + pairs.releaseBuffer(); + return headers.leakRef(); +} +WebCore::FetchHeaders* WebCore__FetchHeaders__createFromUWS(JSC__JSGlobalObject* arg0, void* arg1) +{ + uWS::HttpRequest req = *reinterpret_cast<uWS::HttpRequest*>(arg1); + Vector<KeyValuePair<String, String>> pairs; + pairs.reserveCapacity(55); + for (const auto& header : req) { + auto name = WTF::String(reinterpret_cast<const LChar*>(header.first.data()), header.first.length()); + auto value = WTF::String(reinterpret_cast<const LChar*>(header.second.data()), header.second.length()); + pairs.uncheckedAppend(KeyValuePair<String, String>(name, value)); + } + + RefPtr<WebCore::FetchHeaders> headers = adoptRef(*new WebCore::FetchHeaders({ WebCore::FetchHeaders::Guard::None, {} })); + headers->fill(WebCore::FetchHeaders::Init(WTFMove(pairs))); + pairs.releaseBuffer(); + return headers.leakRef(); +} +void WebCore__FetchHeaders__deref(WebCore__FetchHeaders* arg0) +{ + RefPtr<WebCore::FetchHeaders> clone = arg0; + clone->deref(); +} + +JSC__JSValue WebCore__FetchHeaders__createValue(JSC__JSGlobalObject* arg0, StringPointer* arg1, StringPointer* arg2, const ZigString* arg3, uint32_t count) +{ + Vector<KeyValuePair<String, String>> pairs; + pairs.reserveCapacity(count); + ZigString buf = *arg3; + for (uint32_t i = 0; i < count; i++) { + WTF::String name = Zig::toStringCopy(buf, arg1[i]); + WTF::String value = Zig::toStringCopy(buf, arg2[i]); + pairs.uncheckedAppend(KeyValuePair<String, String>(name, value)); + } + + Ref<WebCore::FetchHeaders> headers = WebCore::FetchHeaders::create(); + headers->fill(WebCore::FetchHeaders::Init(WTFMove(pairs))); + pairs.releaseBuffer(); + return JSC::JSValue::encode(WebCore::toJSNewlyCreated(arg0, reinterpret_cast<Zig::GlobalObject*>(arg0), WTFMove(headers))); +} +void WebCore__FetchHeaders__get_(WebCore__FetchHeaders* headers, const ZigString* arg1, ZigString* arg2) +{ + *arg2 = Zig::toZigString(headers->get(Zig::toString(*arg1)).releaseReturnValue()); +} +bool WebCore__FetchHeaders__has(WebCore__FetchHeaders* headers, const ZigString* arg1) +{ + return headers->has(Zig::toString(*arg1)).releaseReturnValue(); +} +void WebCore__FetchHeaders__put_(WebCore__FetchHeaders* headers, const ZigString* arg1, const ZigString* arg2) +{ + headers->set(Zig::toString(*arg1), Zig::toString(*arg2)); +} +void WebCore__FetchHeaders__remove(WebCore__FetchHeaders* headers, const ZigString* arg1) +{ + headers->remove(Zig::toString(*arg1)); +} + +WebCore__DOMURL* WebCore__DOMURL__cast_(JSC__JSValue JSValue0, JSC::VM* vm) +{ + return WebCoreCast<WebCore::JSDOMURL, WebCore__DOMURL>(JSValue0); +} + +void WebCore__DOMURL__href_(WebCore__DOMURL* domURL, ZigString* arg1) +{ + const WTF::URL& href = domURL->href(); + *arg1 = Zig::toZigString(href.string()); +} +void WebCore__DOMURL__pathname_(WebCore__DOMURL* domURL, ZigString* arg1) +{ + const WTF::URL& href = domURL->href(); + const WTF::StringView& pathname = href.path(); + *arg1 = Zig::toZigString(pathname); +} + +JSC__JSValue SystemError__toErrorInstance(const SystemError* arg0, + JSC__JSGlobalObject* globalObject) +{ + + static const char* system_error_name = "SystemError"; + SystemError err = *arg0; + + JSC::VM& vm = globalObject->vm(); + + auto scope = DECLARE_THROW_SCOPE(vm); + JSC::JSValue message = JSC::jsUndefined(); + if (err.message.len > 0) { + message = Zig::toJSString(err.message, globalObject); + } + + JSC::JSValue options = JSC::jsUndefined(); + + JSC::JSObject* result + = JSC::ErrorInstance::create(globalObject, JSC::ErrorInstance::createStructure(vm, globalObject, globalObject->errorPrototype()), message, options); + + auto clientData = WebCore::clientData(vm); + + if (err.code.len > 0 && !(err.code.len == 1 and err.code.ptr[0] == 0)) { + JSC::JSValue code = Zig::toJSStringGC(err.code, globalObject); + result->putDirect(vm, clientData->builtinNames().codePublicName(), code, + JSC::PropertyAttribute::DontDelete | 0); + + result->putDirect(vm, vm.propertyNames->name, code, JSC::PropertyAttribute::DontEnum | 0); + } else { + + result->putDirect( + vm, vm.propertyNames->name, + JSC::JSValue(JSC::jsOwnedString( + vm, WTF::String(WTF::StringImpl::createWithoutCopying(system_error_name, 11)))), + JSC::PropertyAttribute::DontEnum | 0); + } + + if (err.path.len > 0) { + JSC::JSValue path = JSC::JSValue(Zig::toJSStringGC(err.path, globalObject)); + result->putDirect(vm, clientData->builtinNames().pathPublicName(), path, + JSC::PropertyAttribute::DontDelete | 0); + } + + if (err.syscall.len > 0) { + JSC::JSValue syscall = JSC::JSValue(Zig::toJSString(err.syscall, globalObject)); + result->putDirect(vm, clientData->builtinNames().syscallPublicName(), syscall, + JSC::PropertyAttribute::DontDelete | 0); + } + + result->putDirect(vm, clientData->builtinNames().errnoPublicName(), JSC::JSValue(err.errno_), + JSC::PropertyAttribute::DontDelete | 0); + + RETURN_IF_EXCEPTION(scope, JSC::JSValue::encode(JSC::JSValue())); + scope.release(); + + return JSC::JSValue::encode(JSC::JSValue(result)); +} + +JSC__JSValue +JSC__JSObject__create(JSC__JSGlobalObject* globalObject, size_t initialCapacity, void* arg2, + void (*ArgFn3)(void* arg0, JSC__JSObject* arg1, JSC__JSGlobalObject* arg2)) +{ + JSC::JSObject* object = JSC::constructEmptyObject(globalObject, globalObject->objectPrototype(), initialCapacity); + + ArgFn3(arg2, object, globalObject); + + return JSC::JSValue::encode(object); +} + +JSC__JSValue JSC__JSValue__createEmptyObject(JSC__JSGlobalObject* globalObject, + size_t initialCapacity) +{ + return JSC::JSValue::encode( + JSC::constructEmptyObject(globalObject, globalObject->objectPrototype(), initialCapacity)); +} + +uint32_t JSC__JSValue__getLengthOfArray(JSC__JSValue value, JSC__JSGlobalObject* globalObject) +{ + JSC::JSValue jsValue = JSC::JSValue::decode(value); + JSC::JSObject* object = jsValue.toObject(globalObject); + return JSC::toLength(globalObject, object); +} + +void JSC__JSObject__putRecord(JSC__JSObject* object, JSC__JSGlobalObject* global, ZigString* key, + ZigString* values, size_t valuesLen) +{ + auto scope = DECLARE_THROW_SCOPE(global->vm()); + auto ident = Zig::toIdentifier(*key, global); + JSC::PropertyDescriptor descriptor; + + descriptor.setEnumerable(1); + descriptor.setConfigurable(1); + descriptor.setWritable(1); + + if (valuesLen == 1) { + descriptor.setValue(JSC::jsString(global->vm(), Zig::toString(values[0]))); + } else { + + JSC::JSArray* array = nullptr; + { + JSC::ObjectInitializationScope initializationScope(global->vm()); + if ((array = JSC::JSArray::tryCreateUninitializedRestricted( + initializationScope, nullptr, + global->arrayStructureForIndexingTypeDuringAllocation(JSC::ArrayWithContiguous), + valuesLen))) { + + for (size_t i = 0; i < valuesLen; ++i) { + array->initializeIndexWithoutBarrier( + initializationScope, i, JSC::jsString(global->vm(), Zig::toString(values[i]))); + } + } + } + + if (!array) { + JSC::throwOutOfMemoryError(global, scope); + return; + } + + descriptor.setValue(array); + } + + object->methodTable()->defineOwnProperty(object, global, ident, descriptor, true); + object->putDirect(global->vm(), ident, descriptor.value()); + scope.release(); +} +void JSC__JSValue__putRecord(JSC__JSValue objectValue, JSC__JSGlobalObject* global, ZigString* key, + ZigString* values, size_t valuesLen) +{ + JSC::JSValue objValue = JSC::JSValue::decode(objectValue); + JSC::JSObject* object = objValue.asCell()->getObject(); + auto scope = DECLARE_THROW_SCOPE(global->vm()); + auto ident = Zig::toIdentifier(*key, global); + JSC::PropertyDescriptor descriptor; + + descriptor.setEnumerable(1); + descriptor.setConfigurable(1); + descriptor.setWritable(1); + + if (valuesLen == 1) { + descriptor.setValue(JSC::jsString(global->vm(), Zig::toString(values[0]))); + } else { + + JSC::JSArray* array = nullptr; + { + JSC::ObjectInitializationScope initializationScope(global->vm()); + if ((array = JSC::JSArray::tryCreateUninitializedRestricted( + initializationScope, nullptr, + global->arrayStructureForIndexingTypeDuringAllocation(JSC::ArrayWithContiguous), + valuesLen))) { + + for (size_t i = 0; i < valuesLen; ++i) { + array->initializeIndexWithoutBarrier( + initializationScope, i, JSC::jsString(global->vm(), Zig::toString(values[i]))); + } + } + } + + if (!array) { + JSC::throwOutOfMemoryError(global, scope); + return; + } + + descriptor.setValue(array); + } + + object->methodTable()->defineOwnProperty(object, global, ident, descriptor, true); + object->putDirect(global->vm(), ident, descriptor.value()); + scope.release(); +} + +JSC__JSInternalPromise* JSC__JSValue__asInternalPromise(JSC__JSValue JSValue0) +{ + JSC::JSValue value = JSC::JSValue::decode(JSValue0); + return JSC::jsCast<JSC::JSInternalPromise*>(value); +} + +JSC__JSPromise* JSC__JSValue__asPromise(JSC__JSValue JSValue0) +{ + JSC::JSValue value = JSC::JSValue::decode(JSValue0); + return JSC::jsCast<JSC::JSPromise*>(value); +} +JSC__JSValue JSC__JSValue__createInternalPromise(JSC__JSGlobalObject* globalObject) +{ + JSC::VM& vm = globalObject->vm(); + return JSC::JSValue::encode( + JSC::JSValue(JSC::JSInternalPromise::create(vm, globalObject->internalPromiseStructure()))); +} + +void JSC__JSValue__jsonStringify(JSC__JSValue JSValue0, JSC__JSGlobalObject* arg1, uint32_t arg2, + ZigString* arg3) +{ + JSC::JSValue value = JSC::JSValue::decode(JSValue0); + WTF::String str = JSC::JSONStringify(arg1, value, (unsigned)arg2); + *arg3 = Zig::toZigString(str); +} +unsigned char JSC__JSValue__jsType(JSC__JSValue JSValue0) +{ + JSC::JSValue jsValue = JSC::JSValue::decode(JSValue0); + // if the value is NOT a cell + // asCell will return an invalid pointer rather than a nullptr + if (jsValue.isCell()) + return jsValue.asCell()->type(); + + return 0; +} + +JSC__JSValue JSC__JSPromise__asValue(JSC__JSPromise* arg0, JSC__JSGlobalObject* arg1) +{ + return JSC::JSValue::encode(JSC::JSValue(arg0)); +} +JSC__JSPromise* JSC__JSPromise__create(JSC__JSGlobalObject* arg0) +{ + return JSC::JSPromise::create(arg0->vm(), arg0->promiseStructure()); +} + +// TODO: prevent this from allocating so much memory +void JSC__JSValue___then(JSC__JSValue JSValue0, JSC__JSGlobalObject* globalObject, void* ctx, void (*ArgFn3)(void*, JSC__JSGlobalObject* arg0, JSC__CallFrame* callFrame), void (*ArgFn4)(void*, JSC__JSGlobalObject* arg0, JSC__CallFrame* callFrame)) +{ + + auto* cell = JSC::JSValue::decode(JSValue0).asCell(); + + if (JSC::JSPromise* promise = JSC::jsDynamicCast<JSC::JSPromise*>(cell)) { + handlePromise<JSC::JSPromise, false>(promise, globalObject, ctx, ArgFn3, ArgFn4); + } else if (JSC::JSInternalPromise* promise = JSC::jsDynamicCast<JSC::JSInternalPromise*>(cell)) { + handlePromise<JSC::JSInternalPromise, true>(promise, globalObject, ctx, ArgFn3, ArgFn4); + } +} + +JSC__JSValue JSC__JSValue__parseJSON(JSC__JSValue JSValue0, JSC__JSGlobalObject* arg1) +{ + JSC::JSValue jsValue = JSC::JSValue::decode(JSValue0); + + JSC::JSValue result = JSC::JSONParse(arg1, jsValue.toWTFString(arg1)); + + if (!result) { + result = JSC::JSValue(JSC::createSyntaxError(arg1->globalObject(), "Failed to parse JSON"_s)); + } + + return JSC::JSValue::encode(result); +} + +JSC__JSValue JSC__JSGlobalObject__getCachedObject(JSC__JSGlobalObject* globalObject, const ZigString* arg1) +{ + JSC::VM& vm = globalObject->vm(); + WTF::String string = Zig::toString(*arg1); + auto symbol = vm.privateSymbolRegistry().symbolForKey(string); + JSC::Identifier ident = JSC::Identifier::fromUid(symbol); + JSC::JSValue result = globalObject->getIfPropertyExists(globalObject, ident); + return JSC::JSValue::encode(result); +} +JSC__JSValue JSC__JSGlobalObject__putCachedObject(JSC__JSGlobalObject* globalObject, const ZigString* arg1, JSC__JSValue JSValue2) +{ + JSC::VM& vm = globalObject->vm(); + WTF::String string = Zig::toString(*arg1); + auto symbol = vm.privateSymbolRegistry().symbolForKey(string); + JSC::Identifier ident = JSC::Identifier::fromUid(symbol); + globalObject->putDirect(vm, ident, JSC::JSValue::decode(JSValue2), JSC::PropertyAttribute::DontDelete | JSC::PropertyAttribute::DontEnum); + return JSValue2; +} + +void JSC__JSGlobalObject__deleteModuleRegistryEntry(JSC__JSGlobalObject* global, ZigString* arg1) +{ + JSC::JSMap* map = JSC::jsDynamicCast<JSC::JSMap*>( + global->moduleLoader()->getDirect(global->vm(), JSC::Identifier::fromString(global->vm(), "registry"_s))); + if (!map) + return; + const JSC::Identifier identifier = Zig::toIdentifier(*arg1, global); + JSC::JSValue val = JSC::identifierToJSValue(global->vm(), identifier); + + map->remove(global, val); +} +// This is very naive! +JSC__JSInternalPromise* JSC__VM__reloadModule(JSC__VM* vm, JSC__JSGlobalObject* arg1, + ZigString arg2) +{ + return nullptr; + // JSC::JSMap *map = JSC::jsDynamicCast<JSC::JSMap *>( + // arg1->vm(), arg1->moduleLoader()->getDirect( + // arg1->vm(), JSC::Identifier::fromString(arg1->vm(), "registry"_s))); + + // const JSC::Identifier identifier = Zig::toIdentifier(arg2, arg1); + // JSC::JSValue val = JSC::identifierToJSValue(arg1->vm(), identifier); + + // if (!map->has(arg1, val)) return nullptr; + + // if (JSC::JSObject *registryEntry = + // JSC::jsDynamicCast<JSC::JSObject *>(arg1-> map->get(arg1, val))) { + // auto moduleIdent = JSC::Identifier::fromString(arg1->vm(), "module"); + // if (JSC::JSModuleRecord *record = JSC::jsDynamicCast<JSC::JSModuleRecord *>( + // arg1->vm(), registryEntry->getDirect(arg1->vm(), moduleIdent))) { + // registryEntry->putDirect(arg1->vm(), moduleIdent, JSC::jsUndefined()); + // JSC::JSModuleRecord::destroy(static_cast<JSC::JSCell *>(record)); + // } + // map->remove(arg1, val); + // return JSC__JSModuleLoader__loadAndEvaluateModule(arg1, arg2); + // } + + // return nullptr; +} + +bool JSC__JSValue__isSameValue(JSC__JSValue JSValue0, JSC__JSValue JSValue1, + JSC__JSGlobalObject* globalObject) +{ + JSC::JSValue left = JSC::JSValue::decode(JSValue0); + JSC::JSValue right = JSC::JSValue::decode(JSValue1); + return JSC::sameValue(globalObject, left, right); +} + +// This is the same as the C API version, except it returns a JSValue which may be a *Exception +// We want that so we can return stack traces. +JSC__JSValue JSObjectCallAsFunctionReturnValue(JSContextRef ctx, JSObjectRef object, + JSObjectRef thisObject, size_t argumentCount, + const JSValueRef* arguments); + +JSC__JSValue JSObjectCallAsFunctionReturnValue(JSContextRef ctx, JSObjectRef object, + JSObjectRef thisObject, size_t argumentCount, + const JSValueRef* arguments) +{ + JSC::JSGlobalObject* globalObject = toJS(ctx); + JSC::VM& vm = globalObject->vm(); + + if (!object) + return JSC::JSValue::encode(JSC::JSValue()); + + JSC::JSObject* jsObject = toJS(object); + JSC::JSObject* jsThisObject = toJS(thisObject); + + if (!jsThisObject) + jsThisObject = globalObject->globalThis(); + + JSC::MarkedArgumentBuffer argList; + for (size_t i = 0; i < argumentCount; i++) + argList.append(toJS(globalObject, arguments[i])); + + auto callData = getCallData(jsObject); + if (callData.type == JSC::CallData::Type::None) + return JSC::JSValue::encode(JSC::JSValue()); + + NakedPtr<JSC::Exception> returnedException = nullptr; + auto result = JSC::call(globalObject, jsObject, callData, jsThisObject, argList, returnedException); + + if (returnedException.get()) { + return JSC::JSValue::encode(JSC::JSValue(returnedException.get())); + } + + return JSC::JSValue::encode(result); +} + +JSC__JSValue JSObjectCallAsFunctionReturnValueHoldingAPILock(JSContextRef ctx, JSObjectRef object, + JSObjectRef thisObject, + size_t argumentCount, + const JSValueRef* arguments); + +JSC__JSValue JSObjectCallAsFunctionReturnValueHoldingAPILock(JSContextRef ctx, JSObjectRef object, + JSObjectRef thisObject, + size_t argumentCount, + const JSValueRef* arguments) +{ + JSC::JSGlobalObject* globalObject = toJS(ctx); + JSC::VM& vm = globalObject->vm(); + + JSC::JSLockHolder lock(vm); + + if (!object) + return JSC::JSValue::encode(JSC::JSValue()); + + JSC::JSObject* jsObject = toJS(object); + JSC::JSObject* jsThisObject = toJS(thisObject); + + if (!jsThisObject) + jsThisObject = globalObject->globalThis(); + + JSC::MarkedArgumentBuffer argList; + for (size_t i = 0; i < argumentCount; i++) + argList.append(toJS(globalObject, arguments[i])); + + auto callData = getCallData(jsObject); + if (callData.type == JSC::CallData::Type::None) + return JSC::JSValue::encode(JSC::JSValue()); + + NakedPtr<JSC::Exception> returnedException = nullptr; + auto result = JSC::call(globalObject, jsObject, callData, jsThisObject, argList, returnedException); + + if (returnedException.get()) { + return JSC::JSValue::encode(JSC::JSValue(returnedException.get())); + } + + return JSC::JSValue::encode(result); +} + +#pragma mark - JSC::Exception + +JSC__Exception* JSC__Exception__create(JSC__JSGlobalObject* arg0, JSC__JSObject* arg1, + unsigned char StackCaptureAction2) +{ + return JSC::Exception::create(arg0->vm(), JSC::JSValue(arg1), + StackCaptureAction2 == 0 + ? JSC::Exception::StackCaptureAction::CaptureStack + : JSC::Exception::StackCaptureAction::DoNotCaptureStack); +} +JSC__JSValue JSC__Exception__value(JSC__Exception* arg0) +{ + return JSC::JSValue::encode(arg0->value()); +} + +// #pragma mark - JSC::PropertyNameArray + +// CPP_DECL size_t JSC__PropertyNameArray__length(JSC__PropertyNameArray* arg0); +// CPP_DECL const JSC__PropertyName* +// JSC__PropertyNameArray__next(JSC__PropertyNameArray* arg0, size_t arg1); +// CPP_DECL void JSC__PropertyNameArray__release(JSC__PropertyNameArray* arg0); +size_t JSC__JSObject__getArrayLength(JSC__JSObject* arg0) { return arg0->getArrayLength(); } +JSC__JSValue JSC__JSObject__getIndex(JSC__JSValue jsValue, JSC__JSGlobalObject* arg1, + uint32_t arg3) +{ + return JSC::JSValue::encode(JSC::JSValue::decode(jsValue).toObject(arg1)->getIndex(arg1, arg3)); +} +JSC__JSValue JSC__JSObject__getDirect(JSC__JSObject* arg0, JSC__JSGlobalObject* arg1, + const ZigString* arg2) +{ + return JSC::JSValue::encode(arg0->getDirect(arg1->vm(), Zig::toIdentifier(*arg2, arg1))); +} +void JSC__JSObject__putDirect(JSC__JSObject* arg0, JSC__JSGlobalObject* arg1, const ZigString* key, + JSC__JSValue value) +{ + auto prop = Zig::toIdentifier(*key, arg1); + + arg0->putDirect(arg1->vm(), prop, JSC::JSValue::decode(value)); +} + +#pragma mark - JSC::JSCell + +JSC__JSObject* JSC__JSCell__getObject(JSC__JSCell* arg0) +{ + return arg0->getObject(); +} +bWTF__String JSC__JSCell__getString(JSC__JSCell* arg0, JSC__JSGlobalObject* arg1) +{ + return Wrap<WTF__String, bWTF__String>::wrap(arg0->getString(arg1)); +} +unsigned char JSC__JSCell__getType(JSC__JSCell* arg0) { return arg0->type(); } + +#pragma mark - JSC::JSString + +JSC__JSString* JSC__JSString__createFromOwnedString(JSC__VM* arg0, const WTF__String* arg1) +{ + return JSC::jsOwnedString(reinterpret_cast<JSC__VM&>(arg0), + reinterpret_cast<const WTF__String&>(arg1)); +} +JSC__JSString* JSC__JSString__createFromString(JSC__VM* arg0, const WTF__String* arg1) +{ + return JSC::jsString(reinterpret_cast<JSC__VM&>(arg0), + reinterpret_cast<const WTF__String&>(arg1)); +} +bool JSC__JSString__eql(const JSC__JSString* arg0, JSC__JSGlobalObject* obj, JSC__JSString* arg2) +{ + return arg0->equal(obj, arg2); +} +bool JSC__JSString__is8Bit(const JSC__JSString* arg0) { return arg0->is8Bit(); }; +size_t JSC__JSString__length(const JSC__JSString* arg0) { return arg0->length(); } +JSC__JSObject* JSC__JSString__toObject(JSC__JSString* arg0, JSC__JSGlobalObject* arg1) +{ + return arg0->toObject(arg1); +} + +bWTF__String JSC__JSString__value(JSC__JSString* arg0, JSC__JSGlobalObject* arg1) +{ + return Wrap<WTF__String, bWTF__String>::wrap(arg0->value(arg1)); +} + +#pragma mark - JSC::JSModuleLoader + +// JSC__JSValue +// JSC__JSModuleLoader__dependencyKeysIfEvaluated(JSC__JSModuleLoader* arg0, +// JSC__JSGlobalObject* arg1, JSC__JSModuleRecord* arg2) { +// arg2->depen +// } + +void Microtask__run(void* microtask, void* global) +{ + reinterpret_cast<Zig::JSMicrotaskCallback*>(microtask)->call(); +} + +void Microtask__run_default(void* microtask, void* global) +{ + reinterpret_cast<Zig::JSMicrotaskCallbackDefaultGlobal*>(microtask)->call(reinterpret_cast<Zig::GlobalObject*>(global)); +} + +bool JSC__JSModuleLoader__checkSyntax(JSC__JSGlobalObject* arg0, const JSC__SourceCode* arg1, + bool arg2) +{ + JSC::ParserError error; + bool result = false; + if (arg2) { + result = JSC::checkModuleSyntax(arg0, reinterpret_cast<const JSC::SourceCode&>(arg1), error); + } else { + result = JSC::checkSyntax(reinterpret_cast<JSC__VM&>(arg0->vm()), + reinterpret_cast<const JSC::SourceCode&>(arg1), error); + } + + return result; +} +JSC__JSValue JSC__JSModuleLoader__evaluate(JSC__JSGlobalObject* arg0, const unsigned char* arg1, + size_t arg2, const unsigned char* arg3, size_t arg4, + JSC__JSValue JSValue5, JSC__JSValue* arg6) +{ + WTF::String src = WTF::String(WTF::StringImpl::createWithoutCopying(arg1, arg2)); + WTF::URL origin = WTF::URL::fileURLWithFileSystemPath(WTF::StringView(arg3, arg4)); + + JSC::VM& vm = arg0->vm(); + JSC::JSLockHolder locker(vm); + + JSC::SourceCode sourceCode = JSC::makeSource( + src, JSC::SourceOrigin { origin }, origin.lastPathComponent().toStringWithoutCopying(), + WTF::TextPosition(), JSC::SourceProviderSourceType::Module); + WTF::NakedPtr<JSC::Exception> exception; + auto val = JSC::evaluate(arg0, sourceCode, JSC::JSValue(), exception); + if (exception.get()) { + *arg6 = JSC::JSValue::encode(JSC::JSValue(exception.get())); + } + + vm.drainMicrotasks(); + return JSC::JSValue::encode(val); +} +JSC__JSInternalPromise* JSC__JSModuleLoader__importModule(JSC__JSGlobalObject* arg0, + const JSC__Identifier* arg1) +{ + return JSC::importModule(arg0, *arg1, JSC::JSValue {}, JSC::JSValue {}); +} +JSC__JSValue JSC__JSModuleLoader__linkAndEvaluateModule(JSC__JSGlobalObject* arg0, + const JSC__Identifier* arg1) +{ + return JSC::JSValue::encode(JSC::linkAndEvaluateModule(arg0, *arg1, JSC::JSValue {})); +} + +static JSC::Identifier jsValueToModuleKey(JSC::JSGlobalObject* lexicalGlobalObject, + JSC::JSValue value) +{ + if (value.isSymbol()) + return JSC::Identifier::fromUid(JSC::jsCast<JSC::Symbol*>(value)->privateName()); + return JSC::asString(value)->toIdentifier(lexicalGlobalObject); +} + +static JSC::JSValue doLink(JSC__JSGlobalObject* globalObject, JSC::JSValue moduleKeyValue) +{ + JSC::VM& vm = globalObject->vm(); + JSC::JSLockHolder lock { vm }; + if (!(moduleKeyValue.isString() || moduleKeyValue.isSymbol())) { + return JSC::jsUndefined(); + } + auto scope = DECLARE_THROW_SCOPE(vm); + JSC::Identifier moduleKey = jsValueToModuleKey(globalObject, moduleKeyValue); + RETURN_IF_EXCEPTION(scope, {}); + + return JSC::linkAndEvaluateModule(globalObject, moduleKey, JSC::JSValue()); +} + +JSC__JSValue ReadableStream__empty(Zig::GlobalObject* globalObject) +{ + auto& vm = globalObject->vm(); + auto clientData = WebCore::clientData(vm); + auto* function = globalObject->getDirect(vm, clientData->builtinNames().createEmptyReadableStreamPrivateName()).getObject(); + return JSValue::encode(JSC::call(globalObject, function, JSC::ArgList(), "ReadableStream.create"_s)); +} + +JSC__JSValue JSC__JSValue__createRangeError(const ZigString* message, const ZigString* arg1, + JSC__JSGlobalObject* globalObject) +{ + JSC::VM& vm = globalObject->vm(); + ZigString code = *arg1; + JSC::JSObject* rangeError = Zig::getErrorInstance(message, globalObject).asCell()->getObject(); + static const char* range_error_name = "RangeError"; + + rangeError->putDirect( + vm, vm.propertyNames->name, + JSC::JSValue(JSC::jsOwnedString( + vm, WTF::String(WTF::StringImpl::createWithoutCopying(range_error_name, 10)))), + 0); + + if (code.len > 0) { + auto clientData = WebCore::clientData(vm); + JSC::JSValue codeValue = Zig::toJSStringValue(code, globalObject); + rangeError->putDirect(vm, clientData->builtinNames().codePublicName(), codeValue, + JSC::PropertyAttribute::ReadOnly | 0); + } + + return JSC::JSValue::encode(rangeError); +} +JSC__JSValue JSC__JSValue__createTypeError(const ZigString* message, const ZigString* arg1, + JSC__JSGlobalObject* globalObject) +{ + JSC::VM& vm = globalObject->vm(); + ZigString code = *arg1; + JSC::JSObject* typeError = Zig::getErrorInstance(message, globalObject).asCell()->getObject(); + static const char* range_error_name = "TypeError"; + + typeError->putDirect( + vm, vm.propertyNames->name, + JSC::JSValue(JSC::jsOwnedString( + vm, WTF::String(WTF::StringImpl::createWithoutCopying(range_error_name, 10)))), + 0); + + if (code.len > 0) { + auto clientData = WebCore::clientData(vm); + JSC::JSValue codeValue = Zig::toJSStringValue(code, globalObject); + typeError->putDirect(vm, clientData->builtinNames().codePublicName(), codeValue, 0); + } + + return JSC::JSValue::encode(typeError); +} + +JSC__JSValue JSC__JSValue__fromEntries(JSC__JSGlobalObject* globalObject, ZigString* keys, + ZigString* values, size_t initialCapacity, bool clone) +{ + JSC::VM& vm = globalObject->vm(); + auto scope = DECLARE_THROW_SCOPE(vm); + if (initialCapacity == 0) { + return JSC::JSValue::encode(JSC::constructEmptyObject(globalObject)); + } + + JSC::JSObject* object = nullptr; + { + JSC::ObjectInitializationScope initializationScope(vm); + object = JSC::constructEmptyObject(globalObject, globalObject->objectPrototype(), initialCapacity); + + if (!clone) { + for (size_t i = 0; i < initialCapacity; ++i) { + object->putDirect( + vm, JSC::PropertyName(JSC::Identifier::fromString(vm, Zig::toString(keys[i]))), + Zig::toJSStringValueGC(values[i], globalObject), 0); + } + } else { + for (size_t i = 0; i < initialCapacity; ++i) { + object->putDirect(vm, JSC::PropertyName(Zig::toIdentifier(keys[i], globalObject)), + Zig::toJSStringValueGC(values[i], globalObject), 0); + } + } + } + + return JSC::JSValue::encode(object); +} + +bool JSC__JSValue__asArrayBuffer_(JSC__JSValue JSValue0, JSC__JSGlobalObject* arg1, + Bun__ArrayBuffer* arg2) +{ + JSC::VM& vm = arg1->vm(); + + JSC::JSValue value = JSC::JSValue::decode(JSValue0); + if (!value.isObject()) { + return false; + } + + JSC::JSObject* object = value.getObject(); + + if (JSC::JSArrayBufferView* typedArray = JSC::jsDynamicCast<JSC::JSArrayBufferView*>(object)) { + arg2->ptr = reinterpret_cast<char*>(typedArray->vector()); + arg2->len = typedArray->length(); + arg2->byte_len = typedArray->byteLength(); + arg2->offset = typedArray->byteOffset(); + arg2->cell_type = typedArray->type(); + return true; + } + + if (JSC::ArrayBuffer* buffer = JSC::toPossiblySharedArrayBuffer(vm, value)) { + buffer->pinAndLock(); + arg2->ptr = reinterpret_cast<char*>(buffer->data()); + arg2->len = buffer->byteLength(); + arg2->byte_len = buffer->byteLength(); + arg2->offset = 0; + arg2->cell_type = 40; + return true; + } + + return false; +} +JSC__JSValue JSC__JSValue__createStringArray(JSC__JSGlobalObject* globalObject, ZigString* arg1, + size_t arg2, bool clone) +{ + JSC::VM& vm = globalObject->vm(); + auto scope = DECLARE_THROW_SCOPE(vm); + if (arg2 == 0) { + return JSC::JSValue::encode(JSC::JSArray::create(vm, 0)); + } + + JSC::JSArray* array = nullptr; + { + JSC::ObjectInitializationScope initializationScope(vm); + if ((array = JSC::JSArray::tryCreateUninitializedRestricted( + initializationScope, nullptr, + globalObject->arrayStructureForIndexingTypeDuringAllocation(JSC::ArrayWithContiguous), + arg2))) { + + if (!clone) { + for (size_t i = 0; i < arg2; ++i) { + array->putDirectIndex(globalObject, i, JSC::jsString(vm, Zig::toString(arg1[i]))); + } + } else { + for (size_t i = 0; i < arg2; ++i) { + array->putDirectIndex(globalObject, i, JSC::jsString(vm, Zig::toStringCopy(arg1[i]))); + } + } + } + } + if (!array) { + JSC::throwOutOfMemoryError(globalObject, scope); + return JSC::JSValue::encode(JSC::JSValue()); + } + + RELEASE_AND_RETURN(scope, JSC::JSValue::encode(JSC::JSValue(array))); +} + +JSC__JSValue JSC__JSGlobalObject__createAggregateError(JSC__JSGlobalObject* globalObject, + void** errors, uint16_t errors_count, + const ZigString* arg3) +{ + JSC::VM& vm = globalObject->vm(); + auto scope = DECLARE_THROW_SCOPE(vm); + + JSC::JSValue message = JSC::JSValue(JSC::jsOwnedString(vm, Zig::toString(*arg3))); + JSC::JSValue options = JSC::jsUndefined(); + JSC::JSArray* array = nullptr; + { + JSC::ObjectInitializationScope initializationScope(vm); + if ((array = JSC::JSArray::tryCreateUninitializedRestricted( + initializationScope, nullptr, + globalObject->arrayStructureForIndexingTypeDuringAllocation(JSC::ArrayWithContiguous), + errors_count))) { + + for (uint16_t i = 0; i < errors_count; ++i) { + array->initializeIndexWithoutBarrier( + initializationScope, i, JSC::JSValue(reinterpret_cast<JSC::JSCell*>(errors[i]))); + } + } + } + if (!array) { + JSC::throwOutOfMemoryError(globalObject, scope); + return JSC::JSValue::encode(JSC::JSValue()); + } + + JSC::Structure* errorStructure = globalObject->errorStructure(JSC::ErrorType::AggregateError); + + RELEASE_AND_RETURN(scope, JSC::JSValue::encode(JSC::createAggregateError(globalObject, vm, errorStructure, array, message, options, nullptr, JSC::TypeNothing, false))); +} +// static JSC::JSNativeStdFunction* resolverFunction; +// static JSC::JSNativeStdFunction* rejecterFunction; +// static bool resolverFunctionInitialized = false; + +JSC__JSValue ZigString__toValue(const ZigString* arg0, JSC__JSGlobalObject* arg1) +{ + return JSC::JSValue::encode(JSC::JSValue(JSC::jsOwnedString(arg1->vm(), Zig::toString(*arg0)))); +} + +JSC__JSValue ZigString__to16BitValue(const ZigString* arg0, JSC__JSGlobalObject* arg1) +{ + auto str = WTF::String::fromUTF8(arg0->ptr, arg0->len); + return JSC::JSValue::encode(JSC::JSValue(JSC::jsString(arg1->vm(), str))); +} + +JSC__JSValue ZigString__toExternalU16(const uint16_t* arg0, size_t len, JSC__JSGlobalObject* global) +{ + auto ref = String(ExternalStringImpl::create(reinterpret_cast<const UChar*>(arg0), len, reinterpret_cast<void*>(const_cast<uint16_t*>(arg0)), free_global_string)); + + return JSC::JSValue::encode(JSC::JSValue(JSC::jsString( + global->vm(), WTFMove(ref)))); +} +// This must be a globally allocated string +JSC__JSValue ZigString__toExternalValue(const ZigString* arg0, JSC__JSGlobalObject* arg1) +{ + ZigString str = *arg0; + if (Zig::isTaggedUTF16Ptr(str.ptr)) { + auto ref = String(ExternalStringImpl::create(reinterpret_cast<const UChar*>(Zig::untag(str.ptr)), str.len, Zig::untagVoid(str.ptr), free_global_string)); + + return JSC::JSValue::encode(JSC::JSValue(JSC::jsString( + arg1->vm(), WTFMove(ref)))); + } else { + auto ref = String(ExternalStringImpl::create(Zig::untag(str.ptr), str.len, Zig::untagVoid(str.ptr), free_global_string)); + return JSC::JSValue::encode(JSC::JSValue(JSC::jsString( + arg1->vm(), + WTFMove(ref)))); + } +} + +VirtualMachine* JSC__JSGlobalObject__bunVM(JSC__JSGlobalObject* arg0) +{ + return reinterpret_cast<VirtualMachine*>(reinterpret_cast<Zig::GlobalObject*>(arg0)->bunVM()); +} + +JSC__JSValue ZigString__toValueGC(const ZigString* arg0, JSC__JSGlobalObject* arg1) +{ + return JSC::JSValue::encode(JSC::JSValue(JSC::jsString(arg1->vm(), Zig::toStringCopy(*arg0)))); +} + +void JSC__JSValue__toZigString(JSC__JSValue JSValue0, ZigString* arg1, JSC__JSGlobalObject* arg2) +{ + JSC::JSValue value = JSC::JSValue::decode(JSValue0); + + // if (!value.isString()) { + // arg1->len = 0; + // arg1->ptr = nullptr; + // return; + // } + + auto str = value.toWTFString(arg2); + + if (str.is8Bit()) { + arg1->ptr = str.characters8(); + } else { + arg1->ptr = Zig::taggedUTF16Ptr(str.characters16()); + } + + arg1->len = str.length(); +} + +JSC__JSValue ZigString__external(const ZigString* arg0, JSC__JSGlobalObject* arg1, void* arg2, void (*ArgFn3)(void* arg0, void* arg1, size_t arg2)) +{ + ZigString str + = *arg0; + if (Zig::isTaggedUTF16Ptr(str.ptr)) { + return JSC::JSValue::encode(JSC::JSValue(JSC::jsOwnedString( + arg1->vm(), + WTF::String(ExternalStringImpl::create(reinterpret_cast<const UChar*>(Zig::untag(str.ptr)), str.len, arg2, ArgFn3))))); + } else { + return JSC::JSValue::encode(JSC::JSValue(JSC::jsOwnedString( + arg1->vm(), + WTF::String(ExternalStringImpl::create(reinterpret_cast<const LChar*>(Zig::untag(str.ptr)), str.len, arg2, ArgFn3))))); + } +} + +JSC__JSValue ZigString__toExternalValueWithCallback(const ZigString* arg0, JSC__JSGlobalObject* arg1, void (*ArgFn2)(void* arg2, void* arg0, size_t arg1)) +{ + + ZigString str + = *arg0; + if (Zig::isTaggedUTF16Ptr(str.ptr)) { + return JSC::JSValue::encode(JSC::JSValue(JSC::jsOwnedString( + arg1->vm(), + WTF::String(ExternalStringImpl::create(reinterpret_cast<const UChar*>(Zig::untag(str.ptr)), str.len, nullptr, ArgFn2))))); + } else { + return JSC::JSValue::encode(JSC::JSValue(JSC::jsOwnedString( + arg1->vm(), + WTF::String(ExternalStringImpl::create(reinterpret_cast<const LChar*>(Zig::untag(str.ptr)), str.len, nullptr, ArgFn2))))); + } +} + +JSC__JSValue ZigString__toErrorInstance(const ZigString* str, JSC__JSGlobalObject* globalObject) +{ + return JSC::JSValue::encode(Zig::getErrorInstance(str, globalObject)); +} + +static JSC::EncodedJSValue resolverFunctionCallback(JSC::JSGlobalObject* globalObject, + JSC::CallFrame* callFrame) +{ + return JSC::JSValue::encode(doLink(globalObject, callFrame->argument(0))); +} + +JSC__JSInternalPromise* +JSC__JSModuleLoader__loadAndEvaluateModule(JSC__JSGlobalObject* globalObject, + const ZigString* arg1) +{ + globalObject->vm().drainMicrotasks(); + auto name = Zig::toString(*arg1); + name.impl()->ref(); + + auto* promise = JSC::loadAndEvaluateModule(globalObject, name, JSC::jsUndefined(), JSC::jsUndefined()); + + JSC::JSNativeStdFunction* resolverFunction = JSC::JSNativeStdFunction::create( + globalObject->vm(), globalObject, 1, String(), resolverFunctionCallback); + JSC::JSNativeStdFunction* rejecterFunction = JSC::JSNativeStdFunction::create( + globalObject->vm(), globalObject, 1, String(), + [&arg1](JSC::JSGlobalObject* globalObject, JSC::CallFrame* callFrame) -> JSC::EncodedJSValue { + return JSC::JSValue::encode( + JSC::JSInternalPromise::rejectedPromise(globalObject, callFrame->argument(0))); + }); + + globalObject->vm().drainMicrotasks(); + auto result = promise->then(globalObject, resolverFunction, rejecterFunction); + globalObject->vm().drainMicrotasks(); + + // if (promise->status(globalObject->vm()) == + // JSC::JSPromise::Status::Fulfilled) { + // return reinterpret_cast<JSC::JSInternalPromise*>( + // JSC::JSInternalPromise::resolvedPromise( + // globalObject, + // doLink(globalObject, promise->result(globalObject->vm())) + // ) + // ); + // } + + return result; +} +JSC__JSInternalPromise* +JSC__JSModuleLoader__loadAndEvaluateModuleEntryPoint(JSC__JSGlobalObject* arg0, + const JSC__SourceCode* arg1) +{ + return JSC::loadAndEvaluateModule(arg0, *arg1, JSC::JSValue {}); +} + +#pragma mark - JSC::JSModuleRecord + +bJSC__SourceCode JSC__JSModuleRecord__sourceCode(JSC__JSModuleRecord* arg0) +{ + Wrap<JSC::SourceCode, bJSC__SourceCode> wrapped = Wrap<JSC::SourceCode, bJSC__SourceCode>(arg0->sourceCode()); + return wrapped.result; +} + +#pragma mark - JSC::JSPromise + +void JSC__JSPromise__reject(JSC__JSPromise* arg0, JSC__JSGlobalObject* arg1, + JSC__JSValue JSValue2) +{ + arg0->reject(arg1, JSC::JSValue::decode(JSValue2)); +} +void JSC__JSPromise__rejectAsHandled(JSC__JSPromise* arg0, JSC__JSGlobalObject* arg1, + JSC__JSValue JSValue2) +{ + arg0->rejectAsHandled(arg1, JSC::JSValue::decode(JSValue2)); +} +void JSC__JSPromise__rejectAsHandledException(JSC__JSPromise* arg0, JSC__JSGlobalObject* arg1, + JSC__Exception* arg2) +{ + arg0->rejectAsHandled(arg1, arg2); +} +JSC__JSPromise* JSC__JSPromise__rejectedPromise(JSC__JSGlobalObject* arg0, JSC__JSValue JSValue1) +{ + return JSC::JSPromise::rejectedPromise(arg0, JSC::JSValue::decode(JSValue1)); +} + +void JSC__JSPromise__rejectWithCaughtException(JSC__JSPromise* arg0, JSC__JSGlobalObject* arg1, + bJSC__ThrowScope arg2) +{ + Wrap<JSC::ThrowScope, bJSC__ThrowScope> wrapped = Wrap<JSC::ThrowScope, bJSC__ThrowScope>(arg2); + + arg0->rejectWithCaughtException(arg1, *wrapped.cpp); +} +void JSC__JSPromise__resolve(JSC__JSPromise* arg0, JSC__JSGlobalObject* arg1, + JSC__JSValue JSValue2) +{ + arg0->resolve(arg1, JSC::JSValue::decode(JSValue2)); +} +JSC__JSPromise* JSC__JSPromise__resolvedPromise(JSC__JSGlobalObject* arg0, JSC__JSValue JSValue1) +{ + return JSC::JSPromise::resolvedPromise(arg0, JSC::JSValue::decode(JSValue1)); +} + +JSC__JSValue JSC__JSPromise__result(const JSC__JSPromise* arg0, JSC__VM* arg1) +{ + return JSC::JSValue::encode(arg0->result(reinterpret_cast<JSC::VM&>(arg1))); +} +uint32_t JSC__JSPromise__status(const JSC__JSPromise* arg0, JSC__VM* arg1) +{ + switch (arg0->status(reinterpret_cast<JSC::VM&>(arg1))) { + case JSC::JSPromise::Status::Pending: + return 0; + case JSC::JSPromise::Status::Fulfilled: + return 1; + case JSC::JSPromise::Status::Rejected: + return 2; + default: + return 255; + } +} +bool JSC__JSPromise__isHandled(const JSC__JSPromise* arg0, JSC__VM* arg1) +{ + return arg0->isHandled(reinterpret_cast<JSC::VM&>(arg1)); +} + +#pragma mark - JSC::JSInternalPromise + +JSC__JSInternalPromise* JSC__JSInternalPromise__create(JSC__JSGlobalObject* globalObject) +{ + JSC::VM& vm = globalObject->vm(); + return JSC::JSInternalPromise::create(vm, globalObject->internalPromiseStructure()); +} + +void JSC__JSInternalPromise__reject(JSC__JSInternalPromise* arg0, JSC__JSGlobalObject* arg1, + JSC__JSValue JSValue2) +{ + arg0->reject(arg1, JSC::JSValue::decode(JSValue2)); +} +void JSC__JSInternalPromise__rejectAsHandled(JSC__JSInternalPromise* arg0, + JSC__JSGlobalObject* arg1, JSC__JSValue JSValue2) +{ + arg0->rejectAsHandled(arg1, JSC::JSValue::decode(JSValue2)); +} +void JSC__JSInternalPromise__rejectAsHandledException(JSC__JSInternalPromise* arg0, + JSC__JSGlobalObject* arg1, + JSC__Exception* arg2) +{ + arg0->rejectAsHandled(arg1, arg2); +} +JSC__JSInternalPromise* JSC__JSInternalPromise__rejectedPromise(JSC__JSGlobalObject* arg0, + JSC__JSValue JSValue1) +{ + return reinterpret_cast<JSC::JSInternalPromise*>( + JSC::JSInternalPromise::rejectedPromise(arg0, JSC::JSValue::decode(JSValue1))); +} + +void JSC__JSInternalPromise__rejectWithCaughtException(JSC__JSInternalPromise* arg0, + JSC__JSGlobalObject* arg1, + bJSC__ThrowScope arg2) +{ + Wrap<JSC::ThrowScope, bJSC__ThrowScope> wrapped = Wrap<JSC::ThrowScope, bJSC__ThrowScope>(arg2); + + arg0->rejectWithCaughtException(arg1, *wrapped.cpp); +} +void JSC__JSInternalPromise__resolve(JSC__JSInternalPromise* arg0, JSC__JSGlobalObject* arg1, + JSC__JSValue JSValue2) +{ + arg0->resolve(arg1, JSC::JSValue::decode(JSValue2)); +} +JSC__JSInternalPromise* JSC__JSInternalPromise__resolvedPromise(JSC__JSGlobalObject* arg0, + JSC__JSValue JSValue1) +{ + return reinterpret_cast<JSC::JSInternalPromise*>( + JSC::JSInternalPromise::resolvedPromise(arg0, JSC::JSValue::decode(JSValue1))); +} + +JSC__JSValue JSC__JSInternalPromise__result(const JSC__JSInternalPromise* arg0, JSC__VM* arg1) +{ + return JSC::JSValue::encode(arg0->result(reinterpret_cast<JSC::VM&>(arg1))); +} +uint32_t JSC__JSInternalPromise__status(const JSC__JSInternalPromise* arg0, JSC__VM* arg1) +{ + switch (arg0->status(reinterpret_cast<JSC::VM&>(arg1))) { + case JSC::JSInternalPromise::Status::Pending: + return 0; + case JSC::JSInternalPromise::Status::Fulfilled: + return 1; + case JSC::JSInternalPromise::Status::Rejected: + return 2; + default: + return 255; + } +} +bool JSC__JSInternalPromise__isHandled(const JSC__JSInternalPromise* arg0, JSC__VM* arg1) +{ + return arg0->isHandled(reinterpret_cast<JSC::VM&>(arg1)); +} + +// static JSC::JSFunction* nativeFunctionCallback(JSC__JSGlobalObject* globalObject, void* ctx, JSC__JSValue (*Callback)(void* arg0, JSC__JSGlobalObject* arg1, JSC__JSValue* arg2, size_t arg3)); + +// static JSC::JSFunction* nativeFunctionCallback(JSC__JSGlobalObject* globalObject, void* ctx, JSC__JSValue (*Callback)(void* arg0, JSC__JSGlobalObject* arg1, JSC__JSValue* arg2, size_t arg3)) +// { +// return JSC::JSNativeStdFunction::create( +// globalObject->vm(), globalObject, 1, String(), [&ctx, &Callback](JSC::JSGlobalObject* globalObject, JSC::CallFrame* callFrame) -> JSC::EncodedJSValue { +// size_t argumentCount = callFrame->argumentCount(); +// Vector<JSC__JSValue, 16> arguments; +// arguments.reserveInitialCapacity(argumentCount); +// for (size_t i = 0; i < argumentCount; ++i) +// arguments.uncheckedAppend(JSC::JSValue::encode(callFrame->uncheckedArgument(i))); + +// return Callback(ctx, globalObject, arguments.data(), argumentCount); +// }); +// } + +// JSC__JSInternalPromise* JSC__JSInternalPromise__then_(JSC__JSInternalPromise* promise, JSC__JSGlobalObject* global, void* resolveCtx, JSC__JSValue (*onResolve)(void* arg0, JSC__JSGlobalObject* arg1, JSC__JSValue* arg2, size_t arg3), void* arg4, JSC__JSValue (*ArgFn5)(void* arg0, JSC__JSGlobalObject* arg1, JSC__JSValue* arg2, size_t arg3)) +// { + +// return promise->then(global, nativeFunctionCallback(global, resolveCtx, onResolve), nativeFunctionCallback(global, arg4, ArgFn5)); +// } +// JSC__JSInternalPromise* JSC__JSInternalPromise__thenReject_(JSC__JSInternalPromise* promise, JSC__JSGlobalObject* global, void* arg2, JSC__JSValue (*ArgFn3)(void* arg0, JSC__JSGlobalObject* arg1, JSC__JSValue* arg2, size_t arg3)) +// { +// return promise->then(global, nullptr, nativeFunctionCallback(global, arg2, ArgFn3)); +// } +// JSC__JSInternalPromise* JSC__JSInternalPromise__thenResolve_(JSC__JSInternalPromise* promise, JSC__JSGlobalObject* global, void* arg2, JSC__JSValue (*ArgFn3)(void* arg0, JSC__JSGlobalObject* arg1, JSC__JSValue* arg2, size_t arg3)) +// { +// return promise->then(global, nativeFunctionCallback(global, arg2, ArgFn3), nullptr); +// } +// bool JSC__JSPromise__isInternal(JSC__JSPromise* arg0, JSC__VM* arg1) { +// return arg0->inf +// } + +#pragma mark - JSC::SourceOrigin + +bJSC__SourceOrigin JSC__SourceOrigin__fromURL(const WTF__URL* arg0) +{ + + Wrap<JSC::SourceOrigin, bJSC__SourceOrigin> wrap; + wrap.cpp = new (&wrap.result.bytes) JSC::SourceOrigin(WTF::URL(*arg0)); + return wrap.result; +} + +#pragma mark - JSC::SourceCode + +// class StringSourceProvider : public JSC::SourceProvider { +// public: +// unsigned hash() const override +// { +// return m_source->hash(); +// } + +// StringView source() const override +// { +// return WTF::StringView(m_source); +// } + +// ~StringSourceProvider() { + +// } +// WTF::StringImpl *m_source; + +// StringSourceProvider(const WTF::String& source, const +// JSC::SourceOrigin& sourceOrigin, WTF::String&& sourceURL, const +// WTF::TextPosition& startPosition, JSC::SourceProviderSourceType +// sourceType) +// : JSC::SourceProvider(sourceOrigin, WTFMove(sourceURL), +// startPosition, sourceType) , m_source(source.isNull() ? +// WTF::StringImpl::empty() : source.impl()) +// { +// } +// }; + +void JSC__SourceCode__fromString(JSC__SourceCode* arg0, const WTF__String* arg1, + const JSC__SourceOrigin* arg2, WTF__String* arg3, + unsigned char SourceType4) {} + +bWTF__String JSC__JSFunction__displayName(JSC__JSFunction* arg0, JSC__VM* arg1) +{ + auto wrap = Wrap<WTF::String, bWTF__String>(arg0->displayName(reinterpret_cast<JSC::VM&>(arg1))); + return wrap.result; +}; +bWTF__String JSC__JSFunction__getName(JSC__JSFunction* arg0, JSC__VM* arg1) +{ + auto wrap = Wrap<WTF::String, bWTF__String>(arg0->name(reinterpret_cast<JSC::VM&>(arg1))); + return wrap.result; +}; +bWTF__String JSC__JSFunction__calculatedDisplayName(JSC__JSFunction* arg0, JSC__VM* arg1) +{ + auto wrap = Wrap<WTF::String, bWTF__String>(arg0->calculatedDisplayName(reinterpret_cast<JSC::VM&>(arg1))); + return wrap.result; +}; +#pragma mark - JSC::JSGlobalObject + +JSC__JSValue JSC__JSGlobalObject__generateHeapSnapshot(JSC__JSGlobalObject* globalObject) +{ + JSC::VM& vm = globalObject->vm(); + + JSC::JSLockHolder lock(vm); + // JSC::DeferTermination deferScope(vm); + auto scope = DECLARE_THROW_SCOPE(vm); + + JSC::HeapSnapshotBuilder snapshotBuilder(vm.ensureHeapProfiler()); + snapshotBuilder.buildSnapshot(); + + WTF::String jsonString = snapshotBuilder.json(); + JSC::EncodedJSValue result = JSC::JSValue::encode(JSONParse(globalObject, jsonString)); + scope.releaseAssertNoException(); + return result; +} + +JSC__ArrayIteratorPrototype* +JSC__JSGlobalObject__arrayIteratorPrototype(JSC__JSGlobalObject* arg0) +{ + return arg0->arrayIteratorPrototype(); +}; +JSC__ArrayPrototype* JSC__JSGlobalObject__arrayPrototype(JSC__JSGlobalObject* arg0) +{ + return arg0->arrayPrototype(); +}; +JSC__AsyncFunctionPrototype* +JSC__JSGlobalObject__asyncFunctionPrototype(JSC__JSGlobalObject* arg0) +{ + return arg0->asyncFunctionPrototype(); +}; +JSC__AsyncGeneratorFunctionPrototype* +JSC__JSGlobalObject__asyncGeneratorFunctionPrototype(JSC__JSGlobalObject* arg0) +{ + return arg0->asyncGeneratorFunctionPrototype(); +}; +JSC__AsyncGeneratorPrototype* +JSC__JSGlobalObject__asyncGeneratorPrototype(JSC__JSGlobalObject* arg0) +{ + return arg0->asyncGeneratorPrototype(); +}; +JSC__AsyncIteratorPrototype* +JSC__JSGlobalObject__asyncIteratorPrototype(JSC__JSGlobalObject* arg0) +{ + return arg0->asyncIteratorPrototype(); +}; +JSC__BigIntPrototype* JSC__JSGlobalObject__bigIntPrototype(JSC__JSGlobalObject* arg0) +{ + return arg0->bigIntPrototype(); +}; +JSC__JSObject* JSC__JSGlobalObject__booleanPrototype(JSC__JSGlobalObject* arg0) +{ + return arg0->booleanPrototype(); +}; +JSC__JSObject* JSC__JSGlobalObject__datePrototype(JSC__JSGlobalObject* arg0) +{ + return arg0->datePrototype(); +}; +JSC__JSObject* JSC__JSGlobalObject__errorPrototype(JSC__JSGlobalObject* arg0) +{ + return arg0->errorPrototype(); +}; +JSC__FunctionPrototype* JSC__JSGlobalObject__functionPrototype(JSC__JSGlobalObject* arg0) +{ + return arg0->functionPrototype(); +}; +JSC__GeneratorFunctionPrototype* +JSC__JSGlobalObject__generatorFunctionPrototype(JSC__JSGlobalObject* arg0) +{ + return arg0->generatorFunctionPrototype(); +}; +JSC__GeneratorPrototype* JSC__JSGlobalObject__generatorPrototype(JSC__JSGlobalObject* arg0) +{ + return arg0->generatorPrototype(); +}; +JSC__IteratorPrototype* JSC__JSGlobalObject__iteratorPrototype(JSC__JSGlobalObject* arg0) +{ + return arg0->iteratorPrototype(); +}; +JSC__JSObject* JSC__JSGlobalObject__jsSetPrototype(JSC__JSGlobalObject* arg0) +{ + return arg0->jsSetPrototype(); +}; +JSC__MapIteratorPrototype* JSC__JSGlobalObject__mapIteratorPrototype(JSC__JSGlobalObject* arg0) +{ + return arg0->mapIteratorPrototype(); +}; +JSC__JSObject* JSC__JSGlobalObject__mapPrototype(JSC__JSGlobalObject* arg0) +{ + return arg0->mapPrototype(); +}; +JSC__JSObject* JSC__JSGlobalObject__numberPrototype(JSC__JSGlobalObject* arg0) +{ + return arg0->numberPrototype(); +}; +JSC__ObjectPrototype* JSC__JSGlobalObject__objectPrototype(JSC__JSGlobalObject* arg0) +{ + return arg0->objectPrototype(); +}; +JSC__JSPromisePrototype* JSC__JSGlobalObject__promisePrototype(JSC__JSGlobalObject* arg0) +{ + return arg0->promisePrototype(); +}; +JSC__RegExpPrototype* JSC__JSGlobalObject__regExpPrototype(JSC__JSGlobalObject* arg0) +{ + return arg0->regExpPrototype(); +}; +JSC__SetIteratorPrototype* JSC__JSGlobalObject__setIteratorPrototype(JSC__JSGlobalObject* arg0) +{ + return arg0->setIteratorPrototype(); +}; +JSC__StringPrototype* JSC__JSGlobalObject__stringPrototype(JSC__JSGlobalObject* arg0) +{ + return arg0->stringPrototype(); +}; +JSC__JSObject* JSC__JSGlobalObject__symbolPrototype(JSC__JSGlobalObject* arg0) +{ + return arg0->symbolPrototype(); +}; + +JSC__VM* JSC__JSGlobalObject__vm(JSC__JSGlobalObject* arg0) { return &arg0->vm(); }; + // JSC__JSObject* JSC__JSGlobalObject__createError(JSC__JSGlobalObject* arg0, + // unsigned char ErrorType1, WTF__String* arg2) {}; JSC__JSObject* + // JSC__JSGlobalObject__throwError(JSC__JSGlobalObject* arg0, JSC__JSObject* + // arg1) {}; + +#pragma mark - JSC::JSValue + +JSC__JSCell* JSC__JSValue__asCell(JSC__JSValue JSValue0) +{ + auto value = JSC::JSValue::decode(JSValue0); + return value.asCell(); +} +double JSC__JSValue__asNumber(JSC__JSValue JSValue0) +{ + auto value = JSC::JSValue::decode(JSValue0); + return value.asNumber(); +}; +bJSC__JSObject JSC__JSValue__asObject(JSC__JSValue JSValue0) +{ + auto value = JSC::JSValue::decode(JSValue0); + auto obj = JSC::asObject(value); + return cast<bJSC__JSObject>(&obj); +}; +JSC__JSString* JSC__JSValue__asString(JSC__JSValue JSValue0) +{ + auto value = JSC::JSValue::decode(JSValue0); + return JSC::asString(value); +}; +// uint64_t JSC__JSValue__encode(JSC__JSValue JSValue0) { + +// } +bool JSC__JSValue__eqlCell(JSC__JSValue JSValue0, JSC__JSCell* arg1) +{ + return JSC::JSValue::decode(JSValue0) == arg1; +}; +bool JSC__JSValue__eqlValue(JSC__JSValue JSValue0, JSC__JSValue JSValue1) +{ + return JSC::JSValue::decode(JSValue0) == JSC::JSValue::decode(JSValue1); +}; +JSC__JSValue JSC__JSValue__getPrototype(JSC__JSValue JSValue0, JSC__JSGlobalObject* arg1) +{ + auto value = JSC::JSValue::decode(JSValue0); + return JSC::JSValue::encode(value.getPrototype(arg1)); +} +bool JSC__JSValue__isException(JSC__JSValue JSValue0, JSC__VM* arg1) +{ + return JSC::jsDynamicCast<JSC::Exception*>(JSC::JSValue::decode(JSValue0)) != nullptr; +} +bool JSC__JSValue__isAnyInt(JSC__JSValue JSValue0) +{ + return JSC::JSValue::decode(JSValue0).isAnyInt(); +} +bool JSC__JSValue__isBigInt(JSC__JSValue JSValue0) +{ + return JSC::JSValue::decode(JSValue0).isBigInt(); +} +bool JSC__JSValue__isBigInt32(JSC__JSValue JSValue0) +{ + return JSC::JSValue::decode(JSValue0).isBigInt32(); +} +bool JSC__JSValue__isBoolean(JSC__JSValue JSValue0) +{ + return JSC::JSValue::decode(JSValue0).isBoolean(); +} + +void JSC__JSValue__put(JSC__JSValue JSValue0, JSC__JSGlobalObject* arg1, const ZigString* arg2, JSC__JSValue JSValue3) +{ + JSC::JSObject* object = JSC::JSValue::decode(JSValue0).asCell()->getObject(); + object->putDirect(arg1->vm(), Zig::toIdentifier(*arg2, arg1), JSC::JSValue::decode(JSValue3)); +} + +bool JSC__JSValue__isClass(JSC__JSValue JSValue0, JSC__JSGlobalObject* arg1) +{ + JSC::JSValue value = JSC::JSValue::decode(JSValue0); + return value.isConstructor(); +} +bool JSC__JSValue__isCell(JSC__JSValue JSValue0) { return JSC::JSValue::decode(JSValue0).isCell(); } +bool JSC__JSValue__isCustomGetterSetter(JSC__JSValue JSValue0) +{ + return JSC::JSValue::decode(JSValue0).isCustomGetterSetter(); +} +bool JSC__JSValue__isError(JSC__JSValue JSValue0) +{ + JSC::JSObject* obj = JSC::JSValue::decode(JSValue0).getObject(); + return obj != nullptr && obj->isErrorInstance(); +} + +bool JSC__JSValue__isAggregateError(JSC__JSValue JSValue0, JSC__JSGlobalObject* global) +{ + JSC::JSObject* obj = JSC::JSValue::decode(JSValue0).getObject(); + + if (obj != nullptr) { + if (JSC::ErrorInstance* err = JSC::jsDynamicCast<JSC::ErrorInstance*>(obj)) { + return err->errorType() == JSC::ErrorType::AggregateError; + } + } + + return false; +} + +bool JSC__JSValue__isIterable(JSC__JSValue JSValue, JSC__JSGlobalObject* global) +{ + return JSC::hasIteratorMethod(global, JSC::JSValue::decode(JSValue)); +} + +void JSC__JSValue__forEach(JSC__JSValue JSValue0, JSC__JSGlobalObject* arg1, void* ctx, void (*ArgFn3)(JSC__VM* arg0, JSC__JSGlobalObject* arg1, void* arg2, JSC__JSValue JSValue3)) +{ + + JSC::forEachInIterable( + arg1, JSC::JSValue::decode(JSValue0), + [ArgFn3, ctx](JSC::VM& vm, JSC::JSGlobalObject* global, JSC::JSValue value) -> void { + ArgFn3(&vm, global, ctx, JSC::JSValue::encode(value)); + }); +} + +bool JSC__JSValue__isCallable(JSC__JSValue JSValue0, JSC__VM* arg1) +{ + return JSC::JSValue::decode(JSValue0).isCallable(); +} +bool JSC__JSValue__isGetterSetter(JSC__JSValue JSValue0) +{ + return JSC::JSValue::decode(JSValue0).isGetterSetter(); +} +bool JSC__JSValue__isHeapBigInt(JSC__JSValue JSValue0) +{ + return JSC::JSValue::decode(JSValue0).isHeapBigInt(); +} +bool JSC__JSValue__isInt32(JSC__JSValue JSValue0) +{ + return JSC::JSValue::decode(JSValue0).isInt32(); +} +bool JSC__JSValue__isInt32AsAnyInt(JSC__JSValue JSValue0) +{ + return JSC::JSValue::decode(JSValue0).isInt32AsAnyInt(); +} +bool JSC__JSValue__isNull(JSC__JSValue JSValue0) { return JSC::JSValue::decode(JSValue0).isNull(); } +bool JSC__JSValue__isNumber(JSC__JSValue JSValue0) +{ + return JSC::JSValue::decode(JSValue0).isNumber(); +} +bool JSC__JSValue__isObject(JSC__JSValue JSValue0) +{ + return JSC::JSValue::decode(JSValue0).isObject(); +} +bool JSC__JSValue__isPrimitive(JSC__JSValue JSValue0) +{ + return JSC::JSValue::decode(JSValue0).isPrimitive(); +} +bool JSC__JSValue__isString(JSC__JSValue JSValue0) +{ + return JSC::JSValue::decode(JSValue0).isString(); +} +bool JSC__JSValue__isSymbol(JSC__JSValue JSValue0) +{ + return JSC::JSValue::decode(JSValue0).isSymbol(); +} +bool JSC__JSValue__isUInt32AsAnyInt(JSC__JSValue JSValue0) +{ + return JSC::JSValue::decode(JSValue0).isUInt32AsAnyInt(); +} +bool JSC__JSValue__isUndefined(JSC__JSValue JSValue0) +{ + return JSC::JSValue::decode(JSValue0).isUndefined(); +} +bool JSC__JSValue__isUndefinedOrNull(JSC__JSValue JSValue0) +{ + return JSC::JSValue::decode(JSValue0).isUndefinedOrNull(); +} +JSC__JSValue JSC__JSValue__jsBoolean(bool arg0) +{ + return JSC::JSValue::encode(JSC::jsBoolean(arg0)); +}; +JSC__JSValue JSC__JSValue__jsDoubleNumber(double arg0) +{ + return JSC::JSValue::encode(JSC::jsNumber(arg0)); +} +JSC__JSValue JSC__JSValue__jsNull() { return JSC::JSValue::encode(JSC::jsNull()); }; +JSC__JSValue JSC__JSValue__jsNumberFromChar(unsigned char arg0) +{ + return JSC::JSValue::encode(JSC::jsNumber(arg0)); +}; +JSC__JSValue JSC__JSValue__jsNumberFromDouble(double arg0) +{ + return JSC::JSValue::encode(JSC::jsNumber(arg0)); +}; +JSC__JSValue JSC__JSValue__jsNumberFromInt32(int32_t arg0) +{ + return JSC::JSValue::encode(JSC::jsNumber(arg0)); +}; +JSC__JSValue JSC__JSValue__jsNumberFromInt64(int64_t arg0) +{ + return JSC::JSValue::encode(JSC::jsNumber(arg0)); +}; +JSC__JSValue JSC__JSValue__jsNumberFromU16(uint16_t arg0) +{ + return JSC::JSValue::encode(JSC::jsNumber(arg0)); +}; +JSC__JSValue JSC__JSValue__jsNumberFromUint64(uint64_t arg0) +{ + return JSC::JSValue::encode(JSC::jsNumber(arg0)); +}; + +int64_t JSC__JSValue__toInt64(JSC__JSValue val) +{ + JSC::JSValue _val = JSC::JSValue::decode(val); + + int64_t result = JSC::tryConvertToInt52(_val.asDouble()); + if (result != JSC::JSValue::notInt52) { + return result; + } + + if (_val.isHeapBigInt()) { + + if (auto* heapBigInt = _val.asHeapBigInt()) { + return heapBigInt->toBigInt64(heapBigInt); + } + } + return _val.asAnyInt(); +} + +JSC__JSValue JSC__JSValue__fromInt64NoTruncate(JSC__JSGlobalObject* globalObject, int64_t val) +{ + return JSC::JSValue::encode(JSC::JSValue(JSC::JSBigInt::createFrom(globalObject, val))); +} + +JSC__JSValue JSC__JSValue__fromUInt64NoTruncate(JSC__JSGlobalObject* globalObject, uint64_t val) +{ + return JSC::JSValue::encode(JSC::JSValue(JSC::JSBigInt::createFrom(globalObject, val))); +} + +uint64_t JSC__JSValue__toUInt64NoTruncate(JSC__JSValue val) +{ + JSC::JSValue _val = JSC::JSValue::decode(val); + + int64_t result = JSC::tryConvertToInt52(_val.asDouble()); + if (result != JSC::JSValue::notInt52) { + if (result < 0) + return 0; + + return static_cast<uint64_t>(result); + } + + if (_val.isHeapBigInt()) { + + if (auto* heapBigInt = _val.asHeapBigInt()) { + return heapBigInt->toBigUInt64(heapBigInt); + } + } + + if (!_val.isNumber()) { + return 0; + } + + return static_cast<uint64_t>(_val.asAnyInt()); +} + +JSC__JSValue JSC__JSValue__createObject2(JSC__JSGlobalObject* globalObject, const ZigString* arg1, + const ZigString* arg2, JSC__JSValue JSValue3, + JSC__JSValue JSValue4) +{ + JSC::JSObject* object = JSC::constructEmptyObject(globalObject); + auto key1 = Zig::toIdentifier(*arg1, globalObject); + JSC::PropertyDescriptor descriptor1; + JSC::PropertyDescriptor descriptor2; + + descriptor1.setEnumerable(1); + descriptor1.setConfigurable(1); + descriptor1.setWritable(1); + descriptor1.setValue(JSC::JSValue::decode(JSValue3)); + + auto key2 = Zig::toIdentifier(*arg2, globalObject); + + descriptor2.setEnumerable(1); + descriptor2.setConfigurable(1); + descriptor2.setWritable(1); + descriptor2.setValue(JSC::JSValue::decode(JSValue4)); + + object->methodTable() + ->defineOwnProperty(object, globalObject, key2, descriptor2, true); + object->methodTable() + ->defineOwnProperty(object, globalObject, key1, descriptor1, true); + + return JSC::JSValue::encode(object); +} + +JSC__JSValue JSC__JSValue__getIfPropertyExistsImpl(JSC__JSValue JSValue0, + JSC__JSGlobalObject* globalObject, + const unsigned char* arg1, uint32_t arg2) +{ + + JSC::VM& vm = globalObject->vm(); + JSC::JSObject* object = JSC::JSValue::decode(JSValue0).asCell()->getObject(); + auto propertyName = JSC::PropertyName( + JSC::Identifier::fromString(vm, reinterpret_cast<const LChar*>(arg1), (int)arg2)); + return JSC::JSValue::encode(object->getIfPropertyExists(globalObject, propertyName)); +} + +void JSC__JSValue__getSymbolDescription(JSC__JSValue symbolValue_, JSC__JSGlobalObject* arg1, ZigString* arg2) + +{ + JSC::JSValue symbolValue = JSC::JSValue::decode(symbolValue_); + + if (!symbolValue.isSymbol()) + return; + + JSC::Symbol* symbol = JSC::asSymbol(symbolValue); + JSC::VM& vm = arg1->vm(); + WTF::String string = symbol->description(); + + *arg2 = Zig::toZigString(string); +} + +JSC__JSValue JSC__JSValue__symbolFor(JSC__JSGlobalObject* globalObject, ZigString* arg2) +{ + + JSC::VM& vm = globalObject->vm(); + WTF::String string = Zig::toString(*arg2); + return JSC::JSValue::encode(JSC::Symbol::create(vm, vm.symbolRegistry().symbolForKey(string))); +} + +bool JSC__JSValue__symbolKeyFor(JSC__JSValue symbolValue_, JSC__JSGlobalObject* arg1, ZigString* arg2) +{ + JSC::JSValue symbolValue = JSC::JSValue::decode(symbolValue_); + JSC::VM& vm = arg1->vm(); + + if (!symbolValue.isSymbol()) + return false; + + JSC::PrivateName privateName = JSC::asSymbol(symbolValue)->privateName(); + SymbolImpl& uid = privateName.uid(); + if (!uid.symbolRegistry()) + return false; + + *arg2 = Zig::toZigString(JSC::jsString(vm, String { uid }), arg1); + return true; +} + +bool JSC__JSValue__toBoolean(JSC__JSValue JSValue0) +{ + return JSC::JSValue::decode(JSValue0).asBoolean(); +} +int32_t JSC__JSValue__toInt32(JSC__JSValue JSValue0) +{ + return JSC::JSValue::decode(JSValue0).asInt32(); +} + +JSC__JSValue JSC__JSValue__getErrorsProperty(JSC__JSValue JSValue0, JSC__JSGlobalObject* global) +{ + JSC::JSObject* obj = JSC::JSValue::decode(JSValue0).getObject(); + return JSC::JSValue::encode(obj->getDirect(global->vm(), global->vm().propertyNames->errors)); +} + +JSC__JSValue JSC__JSValue__jsTDZValue() { return JSC::JSValue::encode(JSC::jsTDZValue()); }; +JSC__JSValue JSC__JSValue__jsUndefined() { return JSC::JSValue::encode(JSC::jsUndefined()); }; +JSC__JSObject* JSC__JSValue__toObject(JSC__JSValue JSValue0, JSC__JSGlobalObject* arg1) +{ + JSC::JSValue value = JSC::JSValue::decode(JSValue0); + return value.toObject(arg1); +} + +bJSC__Identifier JSC__JSValue__toPropertyKey(JSC__JSValue JSValue0, JSC__JSGlobalObject* arg1) +{ + JSC::JSValue value = JSC::JSValue::decode(JSValue0); + auto ident = value.toPropertyKey(arg1); + return cast<bJSC__Identifier>(&ident); +} +JSC__JSValue JSC__JSValue__toPropertyKeyValue(JSC__JSValue JSValue0, JSC__JSGlobalObject* arg1) +{ + JSC::JSValue value = JSC::JSValue::decode(JSValue0); + return JSC::JSValue::encode(value.toPropertyKeyValue(arg1)); +} +JSC__JSString* JSC__JSValue__toString(JSC__JSValue JSValue0, JSC__JSGlobalObject* arg1) +{ + JSC::JSValue value = JSC::JSValue::decode(JSValue0); + return value.toString(arg1); +}; +JSC__JSString* JSC__JSValue__toStringOrNull(JSC__JSValue JSValue0, JSC__JSGlobalObject* arg1) +{ + JSC::JSValue value = JSC::JSValue::decode(JSValue0); + return value.toStringOrNull(arg1); +} +bWTF__String JSC__JSValue__toWTFString(JSC__JSValue JSValue0, JSC__JSGlobalObject* arg1) +{ + JSC::JSValue value = JSC::JSValue::decode(JSValue0); + return Wrap<WTF::String, bWTF__String>::wrap(value.toWTFString(arg1)); +}; + +static void populateStackFrameMetadata(const JSC::StackFrame* stackFrame, ZigStackFrame* frame) +{ + frame->source_url = Zig::toZigString(stackFrame->sourceURL()); + + if (stackFrame->isWasmFrame()) { + frame->code_type = ZigStackFrameCodeWasm; + return; + } + + auto m_codeBlock = stackFrame->codeBlock(); + if (m_codeBlock) { + switch (m_codeBlock->codeType()) { + case JSC::EvalCode: { + frame->code_type = ZigStackFrameCodeEval; + return; + } + case JSC::ModuleCode: { + frame->code_type = ZigStackFrameCodeModule; + return; + } + case JSC::GlobalCode: { + frame->code_type = ZigStackFrameCodeGlobal; + return; + } + case JSC::FunctionCode: { + frame->code_type = !m_codeBlock->isConstructor() ? ZigStackFrameCodeFunction : ZigStackFrameCodeConstructor; + break; + } + default: + ASSERT_NOT_REACHED(); + } + } + + auto calleeCell = stackFrame->callee(); + if (!calleeCell || !calleeCell->isObject()) + return; + + JSC::JSObject* callee = JSC::jsCast<JSC::JSObject*>(calleeCell); + auto& vm = m_codeBlock->vm(); + + // Does the code block have a user-defined name property? + JSC::JSValue name = callee->getDirect(vm, vm.propertyNames->name); + if (name && name.isString()) { + auto str = name.toWTFString(m_codeBlock->globalObject()); + frame->function_name = Zig::toZigString(str); + return; + } + + /* For functions (either JSFunction or InternalFunction), fallback to their "native" name + * property. Based on JSC::getCalculatedDisplayName, "inlining" the + * JSFunction::calculatedDisplayName\InternalFunction::calculatedDisplayName calls */ + if (JSC::JSFunction* function = JSC::jsDynamicCast<JSC::JSFunction*>(callee)) { + + WTF::String actualName = function->name(vm); + if (!actualName.isEmpty() || function->isHostOrBuiltinFunction()) { + frame->function_name = Zig::toZigString(actualName); + return; + } + + auto inferred_name = function->jsExecutable()->name(); + frame->function_name = Zig::toZigString(inferred_name.string()); + } + + if (JSC::InternalFunction* function = JSC::jsDynamicCast<JSC::InternalFunction*>(callee)) { + // Based on JSC::InternalFunction::calculatedDisplayName, skipping the "displayName" property + frame->function_name = Zig::toZigString(function->name()); + } +} +// Based on +// https://github.com/mceSystems/node-jsc/blob/master/deps/jscshim/src/shim/JSCStackTrace.cpp#L298 +static void populateStackFramePosition(const JSC::StackFrame* stackFrame, ZigString* source_lines, + int32_t* source_line_numbers, uint8_t source_lines_count, + ZigStackFramePosition* position) +{ + auto m_codeBlock = stackFrame->codeBlock(); + if (!m_codeBlock) + return; + + JSC::BytecodeIndex bytecodeOffset = stackFrame->hasBytecodeIndex() ? stackFrame->bytecodeIndex() : JSC::BytecodeIndex(); + + /* Get the "raw" position info. + * Note that we're using m_codeBlock->unlinkedCodeBlock()->expressionRangeForBytecodeOffset + * rather than m_codeBlock->expressionRangeForBytecodeOffset in order get the "raw" offsets and + * avoid the CodeBlock's expressionRangeForBytecodeOffset modifications to the line and column + * numbers, (we don't need the column number from it, and we'll calculate the line "fixes" + * ourselves). */ + int startOffset = 0; + int endOffset = 0; + int divotPoint = 0; + unsigned line = 0; + unsigned unusedColumn = 0; + m_codeBlock->unlinkedCodeBlock()->expressionRangeForBytecodeIndex( + bytecodeOffset, divotPoint, startOffset, endOffset, line, unusedColumn); + divotPoint += m_codeBlock->sourceOffset(); + + // TODO: evaluate if using the API from UnlinkedCodeBlock can be used instead of iterating + // through source text. + + /* On the first line of the source code, it seems that we need to "fix" the column with the + * starting offset. We currently use codeBlock->source()->startPosition().m_column.oneBasedInt() + * as the offset in the first line rather than codeBlock->firstLineColumnOffset(), which seems + * simpler (and what CodeBlock::expressionRangeForBytecodeOffset does). This is because + * firstLineColumnOffset values seems different from what we expect (according to v8's tests) + * and I haven't dove into the relevant parts in JSC (yet) to figure out why. */ + unsigned columnOffset = line ? 0 : m_codeBlock->source().startColumn().zeroBasedInt(); + + // "Fix" the line number + JSC::ScriptExecutable* executable = m_codeBlock->ownerExecutable(); + if (std::optional<int> overrideLine = executable->overrideLineNumber(m_codeBlock->vm())) { + line = overrideLine.value(); + } else { + line += executable->firstLine(); + } + + // Calculate the staring\ending offsets of the entire expression + int expressionStart = divotPoint - startOffset; + int expressionStop = divotPoint + endOffset; + + // Make sure the range is valid + WTF::StringView sourceString = m_codeBlock->source().provider()->source(); + if (!expressionStop || expressionStart > static_cast<int>(sourceString.length())) { + return; + } + + // Search for the beginning of the line + unsigned int lineStart = expressionStart; + while ((lineStart > 0) && ('\n' != sourceString[lineStart - 1])) { + lineStart--; + } + // Search for the end of the line + unsigned int lineStop = expressionStop; + unsigned int sourceLength = sourceString.length(); + while ((lineStop < sourceLength) && ('\n' != sourceString[lineStop])) { + lineStop++; + } + if (source_lines_count > 1 && source_lines != nullptr) { + auto chars = sourceString.characters8(); + + // Most of the time, when you look at a stack trace, you want a couple lines above + + source_lines[0] = { &chars[lineStart], lineStop - lineStart }; + source_line_numbers[0] = line; + + if (lineStart > 0) { + auto byte_offset_in_source_string = lineStart - 1; + uint8_t source_line_i = 1; + auto remaining_lines_to_grab = source_lines_count - 1; + + while (byte_offset_in_source_string > 0 && remaining_lines_to_grab > 0) { + unsigned int end_of_line_offset = byte_offset_in_source_string; + + // This should probably be code points instead of newlines + while (byte_offset_in_source_string > 0 && chars[byte_offset_in_source_string] != '\n') { + byte_offset_in_source_string--; + } + + // We are at the beginning of the line + source_lines[source_line_i] = { &chars[byte_offset_in_source_string], + end_of_line_offset - byte_offset_in_source_string + 1 }; + + source_line_numbers[source_line_i] = line - source_line_i; + source_line_i++; + + remaining_lines_to_grab--; + + byte_offset_in_source_string -= byte_offset_in_source_string > 0; + } + } + } + + /* Finally, store the source "positions" info. + * Notes: + * - The retrieved column seem to point the "end column". To make sure we're current, we'll + *calculate the columns ourselves, since we've already found where the line starts. Note that in + *v8 it should be 0-based here (in contrast the 1-based column number in v8::StackFrame). + * - The static_casts are ugly, but comes from differences between JSC and v8's api, and should + *be OK since no source should be longer than "max int" chars. + * TODO: If expressionStart == expressionStop, then m_endColumn will be equal to m_startColumn. + *Should we handle this case? + */ + position->expression_start = expressionStart; + position->expression_stop = expressionStop; + position->line = WTF::OrdinalNumber::fromOneBasedInt(static_cast<int>(line)).zeroBasedInt(); + position->column_start = (expressionStart - lineStart) + columnOffset; + position->column_stop = position->column_start + (expressionStop - expressionStart); + position->line_start = lineStart; + position->line_stop = lineStop; + + return; +} +static void populateStackFrame(ZigStackTrace* trace, const JSC::StackFrame* stackFrame, + ZigStackFrame* frame, bool is_top) +{ + populateStackFrameMetadata(stackFrame, frame); + populateStackFramePosition(stackFrame, is_top ? trace->source_lines_ptr : nullptr, + is_top ? trace->source_lines_numbers : nullptr, + is_top ? trace->source_lines_to_collect : 0, &frame->position); +} +static void populateStackTrace(const WTF::Vector<JSC::StackFrame>& frames, ZigStackTrace* trace) +{ + uint8_t frame_i = 0; + size_t stack_frame_i = 0; + const size_t total_frame_count = frames.size(); + const uint8_t frame_count = total_frame_count < trace->frames_len ? total_frame_count : trace->frames_len; + + while (frame_i < frame_count && stack_frame_i < total_frame_count) { + // Skip native frames + while (stack_frame_i < total_frame_count && !(&frames.at(stack_frame_i))->codeBlock() && !(&frames.at(stack_frame_i))->isWasmFrame()) { + stack_frame_i++; + } + if (stack_frame_i >= total_frame_count) + break; + + ZigStackFrame* frame = &trace->frames_ptr[frame_i]; + populateStackFrame(trace, &frames[stack_frame_i], frame, frame_i == 0); + stack_frame_i++; + frame_i++; + } + trace->frames_len = frame_i; +} + +#define SYNTAX_ERROR_CODE 4 + +static void fromErrorInstance(ZigException* except, JSC::JSGlobalObject* global, + JSC::ErrorInstance* err, const Vector<JSC::StackFrame>* stackTrace, + JSC::JSValue val) +{ + JSC::JSObject* obj = JSC::jsDynamicCast<JSC::JSObject*>(val); + + bool getFromSourceURL = false; + if (stackTrace != nullptr && stackTrace->size() > 0) { + populateStackTrace(*stackTrace, &except->stack); + } else if (err->stackTrace() != nullptr && err->stackTrace()->size() > 0) { + populateStackTrace(*err->stackTrace(), &except->stack); + } else { + getFromSourceURL = true; + } + except->code = (unsigned char)err->errorType(); + if (err->isStackOverflowError()) { + except->code = 253; + } + if (err->isOutOfMemoryError()) { + except->code = 8; + } + if (except->code == SYNTAX_ERROR_CODE) { + except->message = Zig::toZigString(err->sanitizedMessageString(global)); + } else if (JSC::JSValue message = obj->getIfPropertyExists(global, global->vm().propertyNames->message)) { + + except->message = Zig::toZigString(message, global); + + } else { + except->message = Zig::toZigString(err->sanitizedMessageString(global)); + } + except->name = Zig::toZigString(err->sanitizedNameString(global)); + except->runtime_type = err->runtimeTypeForCause(); + + auto clientData = WebCore::clientData(global->vm()); + if (except->code != SYNTAX_ERROR_CODE) { + + if (JSC::JSValue syscall = obj->getIfPropertyExists(global, clientData->builtinNames().syscallPublicName())) { + except->syscall = Zig::toZigString(syscall, global); + } + + if (JSC::JSValue code = obj->getIfPropertyExists(global, clientData->builtinNames().codePublicName())) { + except->code_ = Zig::toZigString(code, global); + } + + if (JSC::JSValue path = obj->getIfPropertyExists(global, clientData->builtinNames().pathPublicName())) { + except->path = Zig::toZigString(path, global); + } + + if (JSC::JSValue errno_ = obj->getIfPropertyExists(global, clientData->builtinNames().errnoPublicName())) { + except->errno_ = errno_.toInt32(global); + } + } + + if (getFromSourceURL) { + if (JSC::JSValue sourceURL = obj->getIfPropertyExists(global, global->vm().propertyNames->sourceURL)) { + except->stack.frames_ptr[0].source_url = Zig::toZigString(sourceURL, global); + + if (JSC::JSValue line = obj->getIfPropertyExists(global, global->vm().propertyNames->line)) { + except->stack.frames_ptr[0].position.line = line.toInt32(global); + } + + if (JSC::JSValue column = obj->getIfPropertyExists(global, global->vm().propertyNames->column)) { + except->stack.frames_ptr[0].position.column_start = column.toInt32(global); + } + except->stack.frames_len = 1; + } + } + + except->exception = err; +} + +void exceptionFromString(ZigException* except, JSC::JSValue value, JSC::JSGlobalObject* global) +{ + // Fallback case for when it's a user-defined ErrorLike-object that doesn't inherit from + // ErrorInstance + if (JSC::JSObject* obj = JSC::jsDynamicCast<JSC::JSObject*>(value)) { + if (obj->hasProperty(global, global->vm().propertyNames->name)) { + auto name_str = obj->getIfPropertyExists(global, global->vm().propertyNames->name).toWTFString(global); + except->name = Zig::toZigString(name_str); + if (name_str == "Error"_s) { + except->code = JSErrorCodeError; + } else if (name_str == "EvalError"_s) { + except->code = JSErrorCodeEvalError; + } else if (name_str == "RangeError"_s) { + except->code = JSErrorCodeRangeError; + } else if (name_str == "ReferenceError"_s) { + except->code = JSErrorCodeReferenceError; + } else if (name_str == "SyntaxError"_s) { + except->code = JSErrorCodeSyntaxError; + } else if (name_str == "TypeError"_s) { + except->code = JSErrorCodeTypeError; + } else if (name_str == "URIError"_s) { + except->code = JSErrorCodeURIError; + } else if (name_str == "AggregateError"_s) { + except->code = JSErrorCodeAggregateError; + } + } + + if (JSC::JSValue message = obj->getIfPropertyExists(global, global->vm().propertyNames->message)) { + if (message) { + except->message = Zig::toZigString( + message.toWTFString(global)); + } + } + + if (JSC::JSValue sourceURL = obj->getIfPropertyExists(global, global->vm().propertyNames->sourceURL)) { + if (sourceURL) { + except->stack.frames_ptr[0].source_url = Zig::toZigString( + sourceURL.toWTFString(global)); + except->stack.frames_len = 1; + } + } + + if (JSC::JSValue line = obj->getIfPropertyExists(global, global->vm().propertyNames->line)) { + if (line) { + except->stack.frames_ptr[0].position.line = line.toInt32(global); + except->stack.frames_len = 1; + } + } + + return; + } + auto scope = DECLARE_THROW_SCOPE(global->vm()); + auto str = value.toWTFString(global); + if (scope.exception()) { + scope.clearException(); + scope.release(); + return; + } + scope.release(); + + auto ref = OpaqueJSString::tryCreate(str); + except->message = ZigString { ref->characters8(), ref->length() }; + ref->ref(); +} + +void JSC__VM__releaseWeakRefs(JSC__VM* arg0) +{ + arg0->finalizeSynchronousJSExecution(); +} + +static auto function_string_view = MAKE_STATIC_STRING_IMPL("Function"); +void JSC__JSValue__getClassName(JSC__JSValue JSValue0, JSC__JSGlobalObject* arg1, ZigString* arg2) +{ + JSC::JSCell* cell = JSC::JSValue::decode(JSValue0).asCell(); + if (cell == nullptr) { + arg2->len = 0; + return; + } + + const char* ptr = cell->className(); + auto view = WTF::StringView(ptr, strlen(ptr)); + + // Fallback to .name if className is empty + if (view.length() == 0 || StringView(String(function_string_view)) == view) { + JSC__JSValue__getNameProperty(JSValue0, arg1, arg2); + return; + } else { + *arg2 = Zig::toZigString(view); + return; + } + + arg2->len = 0; +} +void JSC__JSValue__getNameProperty(JSC__JSValue JSValue0, JSC__JSGlobalObject* arg1, + ZigString* arg2) +{ + + JSC::JSObject* obj = JSC::JSValue::decode(JSValue0).getObject(); + JSC::VM& vm = arg1->vm(); + + if (obj == nullptr) { + arg2->len = 0; + return; + } + + JSC::JSValue name = obj->getDirect(vm, vm.propertyNames->toStringTagSymbol); + if (name == JSC::JSValue {}) { + name = obj->getDirect(vm, vm.propertyNames->name); + } + + if (name && name.isString()) { + auto str = name.toWTFString(arg1); + if (!str.isEmpty()) { + *arg2 = Zig::toZigString(str); + return; + } + } + + if (JSC::JSFunction* function = JSC::jsDynamicCast<JSC::JSFunction*>(obj)) { + + WTF::String actualName = function->name(vm); + if (!actualName.isEmpty() || function->isHostOrBuiltinFunction()) { + *arg2 = Zig::toZigString(actualName); + return; + } + + actualName = function->jsExecutable()->name().string(); + + *arg2 = Zig::toZigString(actualName); + return; + } + + if (JSC::InternalFunction* function = JSC::jsDynamicCast<JSC::InternalFunction*>(obj)) { + auto view = WTF::StringView(function->name()); + *arg2 = Zig::toZigString(view); + return; + } + + arg2->len = 0; +} + +void JSC__JSValue__toZigException(JSC__JSValue JSValue0, JSC__JSGlobalObject* arg1, + ZigException* exception) +{ + JSC::JSValue value = JSC::JSValue::decode(JSValue0); + + if (JSC::Exception* jscException = JSC::jsDynamicCast<JSC::Exception*>(value)) { + if (JSC::ErrorInstance* error = JSC::jsDynamicCast<JSC::ErrorInstance*>(jscException->value())) { + fromErrorInstance(exception, arg1, error, &jscException->stack(), value); + return; + } + } + + if (JSC::ErrorInstance* error = JSC::jsDynamicCast<JSC::ErrorInstance*>(value)) { + fromErrorInstance(exception, arg1, error, nullptr, value); + return; + } + + exceptionFromString(exception, value, arg1); +} + +void JSC__Exception__getStackTrace(JSC__Exception* arg0, ZigStackTrace* trace) +{ + populateStackTrace(arg0->stack(), trace); +} + +#pragma mark - JSC::PropertyName + +bool JSC__PropertyName__eqlToIdentifier(JSC__PropertyName* arg0, const JSC__Identifier* arg1) +{ + return (*arg0) == (*arg1); +}; +bool JSC__PropertyName__eqlToPropertyName(JSC__PropertyName* arg0, const JSC__PropertyName* arg1) +{ + return (*arg0) == (*arg1); +}; +const WTF__StringImpl* JSC__PropertyName__publicName(JSC__PropertyName* arg0) +{ + return arg0->publicName(); +}; +const WTF__StringImpl* JSC__PropertyName__uid(JSC__PropertyName* arg0) { return arg0->uid(); }; + +#pragma mark - JSC::VM + +JSC__JSValue JSC__VM__runGC(JSC__VM* vm, bool sync) +{ + JSC::JSLockHolder lock(vm); + + vm->finalizeSynchronousJSExecution(); + + if (sync) { + vm->heap.collectNow(JSC::Sync, JSC::CollectionScope::Full); + } else { + vm->heap.collectSync(JSC::CollectionScope::Full); + } + + vm->finalizeSynchronousJSExecution(); + + return JSC::JSValue::encode(JSC::jsNumber(vm->heap.sizeAfterLastFullCollection())); +} + +bool JSC__VM__isJITEnabled() { return JSC::Options::useJIT(); } + +void JSC__VM__clearExecutionTimeLimit(JSC__VM* vm) +{ + JSC::JSLockHolder locker(vm); + if (vm->watchdog()) + vm->watchdog()->setTimeLimit(JSC::Watchdog::noTimeLimit); +} +void JSC__VM__setExecutionTimeLimit(JSC__VM* vm, double limit) +{ + JSC::JSLockHolder locker(vm); + JSC::Watchdog& watchdog = vm->ensureWatchdog(); + watchdog.setTimeLimit(WTF::Seconds { limit }); +} + +bool JSC__JSValue__isTerminationException(JSC__JSValue JSValue0, JSC__VM* arg1) +{ + JSC::Exception* exception = JSC::jsDynamicCast<JSC::Exception*>(JSC::JSValue::decode(JSValue0)); + return exception != NULL && arg1->isTerminationException(exception); +} + +void JSC__VM__shrinkFootprint(JSC__VM* arg0) { arg0->shrinkFootprintWhenIdle(); }; +void JSC__VM__whenIdle(JSC__VM* arg0, void (*ArgFn1)()) { arg0->whenIdle(ArgFn1); }; + +JSC__VM* JSC__VM__create(unsigned char HeapType0) +{ +} + +void JSC__VM__holdAPILock(JSC__VM* arg0, void* ctx, void (*callback)(void* arg0)) +{ + JSC::JSLockHolder locker(arg0); + callback(ctx); +} + +void JSC__JSString__iterator(JSC__JSString* arg0, JSC__JSGlobalObject* arg1, void* arg2) +{ + jsstring_iterator* iter = (jsstring_iterator*)arg2; + arg0->value(iter); +} +void JSC__VM__deferGC(JSC__VM* vm, void* ctx, void (*callback)(void* arg0)) +{ + JSC::GCDeferralContext deferralContext(reinterpret_cast<JSC__VM&>(vm)); + JSC::DisallowGC disallowGC; + + callback(ctx); +} + +void JSC__VM__deleteAllCode(JSC__VM* arg1, JSC__JSGlobalObject* globalObject) +{ + JSC::JSLockHolder locker(globalObject->vm()); + + arg1->drainMicrotasks(); + if (JSC::JSObject* obj = JSC::jsDynamicCast<JSC::JSObject*>(globalObject->moduleLoader())) { + auto id = JSC::Identifier::fromString(globalObject->vm(), "registry"_s); + JSC::JSMap* map = JSC::JSMap::create(globalObject, globalObject->vm(), globalObject->mapStructure()); + obj->putDirect(globalObject->vm(), id, map); + } + arg1->deleteAllCode(JSC::DeleteAllCodeEffort::PreventCollectionAndDeleteAllCode); + arg1->heap.reportAbandonedObjectGraph(); +} + +void JSC__VM__doWork(JSC__VM* vm) +{ + vm->deferredWorkTimer->runRunLoop(); +} + +void JSC__VM__deinit(JSC__VM* arg1, JSC__JSGlobalObject* globalObject) {} +void JSC__VM__drainMicrotasks(JSC__VM* arg0) { arg0->drainMicrotasks(); } + +bool JSC__VM__executionForbidden(JSC__VM* arg0) { return (*arg0).executionForbidden(); } + +bool JSC__VM__isEntered(JSC__VM* arg0) { return (*arg0).isEntered(); } + +void JSC__VM__setExecutionForbidden(JSC__VM* arg0, bool arg1) { (*arg0).setExecutionForbidden(); } + +void JSC__VM__throwError(JSC__VM* vm_, JSC__JSGlobalObject* arg1, JSC__JSValue value) +{ + JSC::VM& vm = *reinterpret_cast<JSC::VM*>(vm_); + + auto scope = DECLARE_THROW_SCOPE(vm); + JSC::JSObject* error = JSC::JSValue::decode(value).getObject(); + JSC::Exception* exception = JSC::Exception::create(vm, error); + scope.throwException(arg1, exception); +} + +#pragma mark - JSC::ThrowScope + +void JSC__ThrowScope__clearException(JSC__ThrowScope* arg0) +{ + arg0->clearException(); +}; +bJSC__ThrowScope JSC__ThrowScope__declare(JSC__VM* arg0, unsigned char* arg1, unsigned char* arg2, + size_t arg3) +{ + Wrap<JSC::ThrowScope, bJSC__ThrowScope> wrapped = Wrap<JSC::ThrowScope, bJSC__ThrowScope>(); + wrapped.cpp = new (wrapped.alignedBuffer()) JSC::ThrowScope(reinterpret_cast<JSC::VM&>(arg0)); + return wrapped.result; +}; +JSC__Exception* JSC__ThrowScope__exception(JSC__ThrowScope* arg0) { return arg0->exception(); } +void JSC__ThrowScope__release(JSC__ThrowScope* arg0) { arg0->release(); } + +#pragma mark - JSC::CatchScope + +void JSC__CatchScope__clearException(JSC__CatchScope* arg0) +{ + arg0->clearException(); +} +bJSC__CatchScope JSC__CatchScope__declare(JSC__VM* arg0, unsigned char* arg1, unsigned char* arg2, + size_t arg3) +{ + JSC::CatchScope scope = JSC::CatchScope(reinterpret_cast<JSC::VM&>(arg0)); + return cast<bJSC__CatchScope>(&scope); +} +JSC__Exception* JSC__CatchScope__exception(JSC__CatchScope* arg0) { return arg0->exception(); } + +#pragma mark - JSC::Identifier + +void JSC__Identifier__deinit(const JSC__Identifier* arg0) +{ +} + +bool JSC__Identifier__eqlIdent(const JSC__Identifier* arg0, const JSC__Identifier* arg1) +{ + return arg0 == arg1; +}; +bool JSC__Identifier__eqlStringImpl(const JSC__Identifier* arg0, const WTF__StringImpl* arg1) +{ + return JSC::Identifier::equal(arg0->string().impl(), arg1); +}; +bool JSC__Identifier__eqlUTF8(const JSC__Identifier* arg0, const unsigned char* arg1, size_t arg2) +{ + return JSC::Identifier::equal(arg0->string().impl(), reinterpret_cast<const LChar*>(arg1), arg2); +}; +bool JSC__Identifier__neqlIdent(const JSC__Identifier* arg0, const JSC__Identifier* arg1) +{ + return arg0 != arg1; +} +bool JSC__Identifier__neqlStringImpl(const JSC__Identifier* arg0, const WTF__StringImpl* arg1) +{ + return !JSC::Identifier::equal(arg0->string().impl(), arg1); +}; + +bJSC__Identifier JSC__Identifier__fromSlice(JSC__VM* arg0, const unsigned char* arg1, size_t arg2) +{ + JSC::Identifier ident = JSC::Identifier::fromString(reinterpret_cast<JSC__VM&>(arg0), + reinterpret_cast<const LChar*>(arg1), static_cast<int>(arg2)); + return cast<bJSC__Identifier>(&ident); +}; +bJSC__Identifier JSC__Identifier__fromString(JSC__VM* arg0, const WTF__String* arg1) +{ + JSC::Identifier ident = JSC::Identifier::fromString(reinterpret_cast<JSC__VM&>(arg0), + reinterpret_cast<const WTF__String&>(arg1)); + return cast<bJSC__Identifier>(&ident); +}; +// bJSC__Identifier JSC__Identifier__fromUid(JSC__VM* arg0, const +// WTF__StringImpl* arg1) { +// auto ident = JSC::Identifier::fromUid(&arg0, &arg1); +// return *cast<bJSC__Identifier>(&ident); +// }; +bool JSC__Identifier__isEmpty(const JSC__Identifier* arg0) { return arg0->isEmpty(); }; +bool JSC__Identifier__isNull(const JSC__Identifier* arg0) { return arg0->isNull(); }; +bool JSC__Identifier__isPrivateName(const JSC__Identifier* arg0) { return arg0->isPrivateName(); }; +bool JSC__Identifier__isSymbol(const JSC__Identifier* arg0) { return arg0->isSymbol(); }; +size_t JSC__Identifier__length(const JSC__Identifier* arg0) { return arg0->length(); }; + +bWTF__String JSC__Identifier__toString(const JSC__Identifier* arg0) +{ + auto string = arg0->string(); + return cast<bWTF__String>(&string); +}; + +#pragma mark - WTF::StringView + +const uint16_t* WTF__StringView__characters16(const WTF__StringView* arg0) +{ + WTF::StringView* view = (WTF::StringView*)arg0; + return reinterpret_cast<const uint16_t*>(view->characters16()); +} +const unsigned char* WTF__StringView__characters8(const WTF__StringView* arg0) +{ + return reinterpret_cast<const unsigned char*>(arg0->characters8()); +}; + +bool WTF__StringView__is16Bit(const WTF__StringView* arg0) { return !arg0->is8Bit(); }; +bool WTF__StringView__is8Bit(const WTF__StringView* arg0) { return arg0->is8Bit(); }; +bool WTF__StringView__isEmpty(const WTF__StringView* arg0) { return arg0->isEmpty(); }; +size_t WTF__StringView__length(const WTF__StringView* arg0) { return arg0->length(); }; + +#pragma mark - WTF::StringImpl + +const uint16_t* WTF__StringImpl__characters16(const WTF__StringImpl* arg0) +{ + return reinterpret_cast<const uint16_t*>(arg0->characters16()); +} +const unsigned char* WTF__StringImpl__characters8(const WTF__StringImpl* arg0) +{ + return reinterpret_cast<const unsigned char*>(arg0->characters8()); +} + +void WTF__StringView__from8Bit(WTF__StringView* arg0, const unsigned char* arg1, size_t arg2) +{ + *arg0 = WTF::StringView(arg1, arg2); +} + +bool WTF__StringImpl__is16Bit(const WTF__StringImpl* arg0) { return !arg0->is8Bit(); } +bool WTF__StringImpl__is8Bit(const WTF__StringImpl* arg0) { return arg0->is8Bit(); } +bool WTF__StringImpl__isEmpty(const WTF__StringImpl* arg0) { return arg0->isEmpty(); } +bool WTF__StringImpl__isExternal(const WTF__StringImpl* arg0) { return arg0->isExternal(); } +bool WTF__StringImpl__isStatic(const WTF__StringImpl* arg0) { return arg0->isStatic(); } +size_t WTF__StringImpl__length(const WTF__StringImpl* arg0) { return arg0->length(); } + +#pragma mark - WTF::ExternalStringImpl + +const uint16_t* WTF__ExternalStringImpl__characters16(const WTF__ExternalStringImpl* arg0) +{ + return reinterpret_cast<const uint16_t*>(arg0->characters16()); +} +const unsigned char* WTF__ExternalStringImpl__characters8(const WTF__ExternalStringImpl* arg0) +{ + return reinterpret_cast<const unsigned char*>(arg0->characters8()); +} + +bool WTF__ExternalStringImpl__is16Bit(const WTF__ExternalStringImpl* arg0) +{ + return !arg0->is8Bit(); +} +bool WTF__ExternalStringImpl__is8Bit(const WTF__ExternalStringImpl* arg0) { return arg0->is8Bit(); } +bool WTF__ExternalStringImpl__isEmpty(const WTF__ExternalStringImpl* arg0) +{ + return arg0->isEmpty(); +} +bool WTF__ExternalStringImpl__isExternal(const WTF__ExternalStringImpl* arg0) +{ + return arg0->isExternal(); +} +bool WTF__ExternalStringImpl__isStatic(const WTF__ExternalStringImpl* arg0) +{ + return arg0->isStatic(); +} +size_t WTF__ExternalStringImpl__length(const WTF__ExternalStringImpl* arg0) +{ + return arg0->length(); +} + +#pragma mark - WTF::String + +const uint16_t* WTF__String__characters16(WTF__String* arg0) +{ + return reinterpret_cast<const uint16_t*>(arg0->characters16()); +}; +const unsigned char* WTF__String__characters8(WTF__String* arg0) +{ + return reinterpret_cast<const unsigned char*>(arg0->characters8()); +}; + +bool WTF__String__eqlSlice(WTF__String* arg0, const unsigned char* arg1, size_t arg2) +{ + return WTF::equal(arg0->impl(), reinterpret_cast<const LChar*>(arg1), arg2); +} +bool WTF__String__eqlString(WTF__String* arg0, const WTF__String* arg1) { return arg0 == arg1; } +const WTF__StringImpl* WTF__String__impl(WTF__String* arg0) { return arg0->impl(); } + +bool WTF__String__is16Bit(WTF__String* arg0) { return !arg0->is8Bit(); } +bool WTF__String__is8Bit(WTF__String* arg0) { return arg0->is8Bit(); } +bool WTF__String__isEmpty(WTF__String* arg0) { return arg0->isEmpty(); } +bool WTF__String__isExternal(WTF__String* arg0) { return arg0->impl()->isExternal(); } +bool WTF__String__isStatic(WTF__String* arg0) { return arg0->impl()->isStatic(); } +size_t WTF__String__length(WTF__String* arg0) { return arg0->length(); } + +bWTF__String WTF__String__createFromExternalString(bWTF__ExternalStringImpl arg0) +{ + auto external = Wrap<WTF::ExternalStringImpl, bWTF__ExternalStringImpl>(arg0); + return Wrap<WTF::String, bWTF__String>(WTF::String(external.cpp)).result; +}; + +void WTF__String__createWithoutCopyingFromPtr(WTF__String* str, const unsigned char* arg0, + size_t arg1) +{ + auto new_str = new (reinterpret_cast<char*>(str)) WTF::String(arg0, arg1); + new_str->impl()->ref(); +} + +#pragma mark - WTF::URL + +bWTF__StringView WTF__URL__encodedPassword(WTF__URL* arg0) +{ + auto result = arg0->encodedPassword(); + return cast<bWTF__StringView>(&result); +}; +bWTF__StringView WTF__URL__encodedUser(WTF__URL* arg0) +{ + auto result = arg0->encodedUser(); + return cast<bWTF__StringView>(&result); +}; +bWTF__String WTF__URL__fileSystemPath(WTF__URL* arg0) +{ + auto result = arg0->fileSystemPath(); + return cast<bWTF__String>(&result); +}; +bWTF__StringView WTF__URL__fragmentIdentifier(WTF__URL* arg0) +{ + auto result = arg0->fragmentIdentifier(); + return cast<bWTF__StringView>(&result); +}; +bWTF__StringView WTF__URL__fragmentIdentifierWithLeadingNumberSign(WTF__URL* arg0) +{ + auto result = arg0->fragmentIdentifierWithLeadingNumberSign(); + return cast<bWTF__StringView>(&result); +}; +void WTF__URL__fromFileSystemPath(WTF::URL* result, bWTF__StringView arg0) +{ + Wrap<WTF::StringView, bWTF__StringView> fsPath = Wrap<WTF::StringView, bWTF__StringView>(&arg0); + *result = WTF::URL::fileURLWithFileSystemPath(*fsPath.cpp); + result->string().impl()->ref(); +}; +bWTF__URL WTF__URL__fromString(bWTF__String arg0, bWTF__String arg1) +{ + WTF::URL url = WTF::URL(WTF::URL(), cast<WTF::String>(&arg1)); + return cast<bWTF__URL>(&url); +}; +bWTF__StringView WTF__URL__host(WTF__URL* arg0) +{ + auto result = arg0->host(); + return cast<bWTF__StringView>(&result); +}; +bWTF__String WTF__URL__hostAndPort(WTF__URL* arg0) +{ + auto result = arg0->hostAndPort(); + return cast<bWTF__String>(&result); +}; +bool WTF__URL__isEmpty(const WTF__URL* arg0) { return arg0->isEmpty(); }; +bool WTF__URL__isValid(const WTF__URL* arg0) { return arg0->isValid(); }; +bWTF__StringView WTF__URL__lastPathComponent(WTF__URL* arg0) +{ + auto result = arg0->lastPathComponent(); + return cast<bWTF__StringView>(&result); +}; +bWTF__String WTF__URL__password(WTF__URL* arg0) +{ + auto result = arg0->password(); + return cast<bWTF__String>(&result); +}; +bWTF__StringView WTF__URL__path(WTF__URL* arg0) +{ + auto wrap = Wrap<WTF::StringView, bWTF__StringView>(arg0->path()); + return wrap.result; +}; +bWTF__StringView WTF__URL__protocol(WTF__URL* arg0) +{ + auto result = arg0->protocol(); + return cast<bWTF__StringView>(&result); +}; +bWTF__String WTF__URL__protocolHostAndPort(WTF__URL* arg0) +{ + auto result = arg0->protocolHostAndPort(); + return cast<bWTF__String>(&result); +}; +bWTF__StringView WTF__URL__query(WTF__URL* arg0) +{ + auto result = arg0->query(); + return cast<bWTF__StringView>(&result); +}; +bWTF__StringView WTF__URL__queryWithLeadingQuestionMark(WTF__URL* arg0) +{ + auto result = arg0->queryWithLeadingQuestionMark(); + return cast<bWTF__StringView>(&result); +}; +bWTF__String WTF__URL__stringWithoutFragmentIdentifier(WTF__URL* arg0) +{ + auto result = arg0->stringWithoutFragmentIdentifier(); + return cast<bWTF__String>(&result); +}; +bWTF__StringView WTF__URL__stringWithoutQueryOrFragmentIdentifier(WTF__URL* arg0) +{ + auto result = arg0->viewWithoutQueryOrFragmentIdentifier(); + return cast<bWTF__StringView>(&result); +}; +bWTF__URL WTF__URL__truncatedForUseAsBase(WTF__URL* arg0) +{ + auto result = arg0->truncatedForUseAsBase(); + return cast<bWTF__URL>(&result); +}; +bWTF__String WTF__URL__user(WTF__URL* arg0) +{ + auto result = arg0->user(); + return cast<bWTF__String>(&result); +}; + +void WTF__URL__setHost(WTF__URL* arg0, bWTF__StringView arg1) +{ + arg0->setHost(*Wrap<WTF::StringView, bWTF__StringView>::unwrap(&arg1)); +}; +void WTF__URL__setHostAndPort(WTF__URL* arg0, bWTF__StringView arg1) +{ + arg0->setHostAndPort(*Wrap<WTF::StringView, bWTF__StringView>::unwrap(&arg1)); +}; +void WTF__URL__setPassword(WTF__URL* arg0, bWTF__StringView arg1) +{ + arg0->setPassword(*Wrap<WTF::StringView, bWTF__StringView>::unwrap(&arg1)); +}; +void WTF__URL__setPath(WTF__URL* arg0, bWTF__StringView arg1) +{ + arg0->setPath(*Wrap<WTF::StringView, bWTF__StringView>::unwrap(&arg1)); +}; +void WTF__URL__setProtocol(WTF__URL* arg0, bWTF__StringView arg1) +{ + arg0->setProtocol(*Wrap<WTF::StringView, bWTF__StringView>::unwrap(&arg1)); +}; +void WTF__URL__setQuery(WTF__URL* arg0, bWTF__StringView arg1) +{ + arg0->setQuery(*Wrap<WTF::StringView, bWTF__StringView>::unwrap(&arg1)); +}; +void WTF__URL__setUser(WTF__URL* arg0, bWTF__StringView arg1) +{ + arg0->setUser(*Wrap<WTF::StringView, bWTF__StringView>::unwrap(&arg1)); +}; + +JSC__JSValue JSC__JSPromise__rejectedPromiseValue(JSC__JSGlobalObject* arg0, + JSC__JSValue JSValue1) +{ + return JSC::JSValue::encode( + JSC::JSPromise::rejectedPromise(arg0, JSC::JSValue::decode(JSValue1))); +} +JSC__JSValue JSC__JSPromise__resolvedPromiseValue(JSC__JSGlobalObject* arg0, + JSC__JSValue JSValue1) +{ + return JSC::JSValue::encode( + JSC::JSPromise::resolvedPromise(arg0, JSC::JSValue::decode(JSValue1))); +} +} + +JSC__JSValue JSC__JSValue__createUninitializedUint8Array(JSC__JSGlobalObject* arg0, size_t arg1) +{ + JSC::JSValue value = JSC::JSUint8Array::createUninitialized(arg0, arg0->m_typedArrayUint8.get(arg0), arg1); + return JSC::JSValue::encode(value); +}
\ No newline at end of file |