mirrors/bun.sh
1
0
Fork 0
mirror of https://github.com/oven-sh/bun synced 2026-02-09 10:28:47 +00:00
Code Issues Packages Projects Releases Wiki Activity

Fix lazy loading internal streams

Browse Source
This commit is contained in:
Jarred Sumner
2022-06-15 22:10:12 -07:00
parent 56e88fb4dd
commit e6fbbd48db
13 changed files with 423 additions and 359 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
src/javascript/jsc/bindings/BunBuiltinNames.h
View File

@@ -125,12 +125,13 @@ using namespace JSC;
macro(join) \
macro(kind) \
macro(lazy) \
macro(lazyStreamPrototypeMap) \
macro(lazyLoad) \
macro(localStreams) \
macro(makeDOMException) \
macro(makeGetterTypeError) \
macro(makeThisTypeError) \
macro(map) \
macro(nativeReadableStreamPrototype) \
macro(nextTick) \
macro(normalize) \
macro(on) \

47
src/javascript/jsc/bindings/ReadableByteStreamInternalsBuiltins.cpp
View File

@@ -49,7 +49,7 @@ namespace WebCore {
const JSC::ConstructAbility s_readableByteStreamInternalsPrivateInitializeReadableByteStreamControllerCodeConstructAbility = JSC::ConstructAbility::CannotConstruct;
const JSC::ConstructorKind s_readableByteStreamInternalsPrivateInitializeReadableByteStreamControllerCodeConstructorKind = JSC::ConstructorKind::None;
const int s_readableByteStreamInternalsPrivateInitializeReadableByteStreamControllerCodeLength = 2089;
const int s_readableByteStreamInternalsPrivateInitializeReadableByteStreamControllerCodeLength = 2365;
static const JSC::Intrinsic s_readableByteStreamInternalsPrivateInitializeReadableByteStreamControllerCodeIntrinsic = JSC::NoIntrinsic;
const char* const s_readableByteStreamInternalsPrivateInitializeReadableByteStreamControllerCode =
"(function (stream, underlyingByteSource, highWaterMark)\n" \
@@ -69,7 +69,7 @@ const char* const s_readableByteStreamInternalsPrivateInitializeReadableByteStre
" @putByIdDirectPrivate(this, \"pulling\", false);\n" \
" @readableByteStreamControllerClearPendingPullIntos(this);\n" \
" @putByIdDirectPrivate(this, \"queue\", @newQueue());\n" \
" @putByIdDirectPrivate(this, \"started\", -1);\n" \
" @putByIdDirectPrivate(this, \"started\", 0);\n" \
" @putByIdDirectPrivate(this, \"closeRequested\", false);\n" \
"\n" \
" let hwm = @toNumber(highWaterMark);\n" \
@@ -86,44 +86,34 @@ const char* const s_readableByteStreamInternalsPrivateInitializeReadableByteStre
" @putByIdDirectPrivate(this, \"autoAllocateChunkSize\", autoAllocateChunkSize);\n" \
" @putByIdDirectPrivate(this, \"pendingPullIntos\", @createFIFO());\n" \
"\n" \
"\n" \
" const controller = this;\n" \
" @promiseInvokeOrNoopNoCatch(@getByIdDirectPrivate(controller, \"underlyingByteSource\"), \"start\", [controller]).@then(() => {\n" \
" @putByIdDirectPrivate(controller, \"started\", 1);\n" \
" @assert(!@getByIdDirectPrivate(controller, \"pulling\"));\n" \
" @assert(!@getByIdDirectPrivate(controller, \"pullAgain\"));\n" \
" @readableByteStreamControllerCallPullIfNeeded(controller);\n" \
" }, (error) => {\n" \
" if (@getByIdDirectPrivate(stream, \"state\") === @streamReadable)\n" \
" @readableByteStreamControllerError(controller, error);\n" \
" });\n" \
"\n" \
" @putByIdDirectPrivate(this, \"cancel\", @readableByteStreamControllerCancel);\n" \
" @putByIdDirectPrivate(this, \"pull\", @readableByteStreamControllerPull);\n" \
"\n" \
" if (@getByIdDirectPrivate(underlyingByteSource, \"lazy\") === true) {\n" \
" @putByIdDirectPrivate(this, \"start\", () => @readableStreamByteStreamControllerStart(this));\n" \
" } else {\n" \
" @putByIdDirectPrivate(this, \"start\", @undefined); \n" \
" @readableStreamByteStreamControllerStart(this);\n" \
" }\n" \
"\n" \
" \n" \
" return this;\n" \
"})\n" \
;
const JSC::ConstructAbility s_readableByteStreamInternalsReadableStreamByteStreamControllerStartCodeConstructAbility = JSC::ConstructAbility::CannotConstruct;
const JSC::ConstructorKind s_readableByteStreamInternalsReadableStreamByteStreamControllerStartCodeConstructorKind = JSC::ConstructorKind::None;
const int s_readableByteStreamInternalsReadableStreamByteStreamControllerStartCodeLength = 972;
const int s_readableByteStreamInternalsReadableStreamByteStreamControllerStartCodeLength = 107;
static const JSC::Intrinsic s_readableByteStreamInternalsReadableStreamByteStreamControllerStartCodeIntrinsic = JSC::NoIntrinsic;
const char* const s_readableByteStreamInternalsReadableStreamByteStreamControllerStartCode =
"(function (controller) {\n" \
" \"use strict\";\n" \
" @putByIdDirectPrivate(controller, \"start\", @undefined);\n" \
" \n" \
" if (@getByIdDirectPrivate(controller, \"started\") !== -1)\n" \
" return;\n" \
"\n" \
" @putByIdDirectPrivate(controller, \"started\", 0);\n" \
" var stream = @getByIdDirectPrivate(controller, \"controlledReadableStream\");\n" \
" return @promiseInvokeOrNoopNoCatch(@getByIdDirectPrivate(controller, \"underlyingByteSource\"), \"start\", [controller]).@then(() => {\n" \
" @putByIdDirectPrivate(controller, \"started\", 1);\n" \
" @assert(!@getByIdDirectPrivate(controller, \"pulling\"));\n" \
" @assert(!@getByIdDirectPrivate(controller, \"pullAgain\"));\n" \
" @readableByteStreamControllerCallPullIfNeeded(controller);\n" \
" }, (error) => {\n" \
" var stream = @getByIdDirectPrivate(controller, \"controlledReadableStream\");\n" \
" if (stream && @getByIdDirectPrivate(stream, \"state\") === @streamReadable)\n" \
" @readableByteStreamControllerError(controller, error);\n" \
" });\n" \
"})\n" \
;
@@ -339,7 +329,7 @@ const char* const s_readableByteStreamInternalsReadableByteStreamControllerHandl
const JSC::ConstructAbility s_readableByteStreamInternalsReadableByteStreamControllerPullCodeConstructAbility = JSC::ConstructAbility::CannotConstruct;
const JSC::ConstructorKind s_readableByteStreamInternalsReadableByteStreamControllerPullCodeConstructorKind = JSC::ConstructorKind::None;
const int s_readableByteStreamInternalsReadableByteStreamControllerPullCodeLength = 1598;
const int s_readableByteStreamInternalsReadableByteStreamControllerPullCodeLength = 1610;
static const JSC::Intrinsic s_readableByteStreamInternalsReadableByteStreamControllerPullCodeIntrinsic = JSC::NoIntrinsic;
const char* const s_readableByteStreamInternalsReadableByteStreamControllerPullCode =
"(function (controller)\n" \
@@ -348,8 +338,7 @@ const char* const s_readableByteStreamInternalsReadableByteStreamControllerPullC
"\n" \
" const stream = @getByIdDirectPrivate(controller, \"controlledReadableStream\");\n" \
" @assert(@readableStreamHasDefaultReader(stream));\n" \
"\n" \
" if (@getByIdDirectPrivate(controller, \"queue\").size > 0) {\n" \
" if (@getByIdDirectPrivate(controller, \"queue\").content?.isNotEmpty()) {\n" \
" const entry = @getByIdDirectPrivate(controller, \"queue\").content.shift();\n" \
" @getByIdDirectPrivate(controller, \"queue\").size -= entry.byteLength;\n" \
" @readableByteStreamControllerHandleQueueDrain(controller);\n" \

41
src/javascript/jsc/bindings/ReadableStreamBuiltins.cpp
View File

@@ -49,7 +49,7 @@ namespace WebCore {
const JSC::ConstructAbility s_readableStreamInitializeReadableStreamCodeConstructAbility = JSC::ConstructAbility::CannotConstruct;
const JSC::ConstructorKind s_readableStreamInitializeReadableStreamCodeConstructorKind = JSC::ConstructorKind::None;
const int s_readableStreamInitializeReadableStreamCodeLength = 2262;
const int s_readableStreamInitializeReadableStreamCodeLength = 2501;
static const JSC::Intrinsic s_readableStreamInitializeReadableStreamCodeIntrinsic = JSC::NoIntrinsic;
const char* const s_readableStreamInitializeReadableStreamCode =
"(function (underlyingSource, strategy)\n" \
@@ -57,7 +57,7 @@ const char* const s_readableStreamInitializeReadableStreamCode =
" \"use strict\";\n" \
"\n" \
" if (underlyingSource === @undefined)\n" \
" underlyingSource = { };\n" \
" underlyingSource = { @bunNativeType: 0, @bunNativePtr: 0, @lazy: false };\n" \
" if (strategy === @undefined)\n" \
" strategy = { };\n" \
"\n" \
@@ -77,6 +77,8 @@ const char* const s_readableStreamInitializeReadableStreamCode =
" \n" \
" //\n" \
" @putByIdDirectPrivate(this, \"readableStreamController\", null);\n" \
" @putByIdDirectPrivate(this, \"bunNativeType\", @getByIdDirectPrivate(underlyingSource, \"bunNativeType\") ?? 0);\n" \
" @putByIdDirectPrivate(this, \"bunNativePtr\", @getByIdDirectPrivate(underlyingSource, \"bunNativePtr\") ?? 0);\n" \
"\n" \
" const isDirect = underlyingSource.type === \"direct\";\n" \
" //\n" \
@@ -93,16 +95,20 @@ const char* const s_readableStreamInitializeReadableStreamCode =
" return this;\n" \
" }\n" \
" if (isDirect) {\n" \
" if (\"start\" in underlyingSource && typeof underlyingSource.start === \"function\")\n" \
" @throwTypeError(\"\\\"start\\\" for direct streams are not implemented yet\");\n" \
" \n" \
" @putByIdDirectPrivate(this, \"start\", () => @createReadableStreamController.@call(this, underlyingSource, strategy, true));\n" \
" @putByIdDirectPrivate(this, \"start\", () => @createReadableStreamController(this, underlyingSource, strategy));\n" \
" } else if (isLazy) {\n" \
" const autoAllocateChunkSize = underlyingSource.autoAllocateChunkSize;\n" \
" @putByIdDirectPrivate(this, \"start\", () => @lazyLoadStream(this, autoAllocateChunkSize));\n" \
"\n" \
" \n" \
" @putByIdDirectPrivate(this, \"start\", () => {\n" \
" const instance = @lazyLoadStream(this, autoAllocateChunkSize);\n" \
" if (instance) {\n" \
" @createReadableStreamController(this, instance, strategy);\n" \
" }\n" \
" });\n" \
" } else {\n" \
" @putByIdDirectPrivate(this, \"start\", @undefined);\n" \
" @createReadableStreamController.@call(this, underlyingSource, strategy, false);\n" \
" @createReadableStreamController(this, underlyingSource, strategy);\n" \
" }\n" \
" \n" \
"\n" \
@@ -383,10 +389,12 @@ const char* const s_readableStreamConsumeReadableStreamCode =
const JSC::ConstructAbility s_readableStreamCreateEmptyReadableStreamCodeConstructAbility = JSC::ConstructAbility::CannotConstruct;
const JSC::ConstructorKind s_readableStreamCreateEmptyReadableStreamCodeConstructorKind = JSC::ConstructorKind::None;
const int s_readableStreamCreateEmptyReadableStreamCodeLength = 137;
const int s_readableStreamCreateEmptyReadableStreamCodeLength = 156;
static const JSC::Intrinsic s_readableStreamCreateEmptyReadableStreamCodeIntrinsic = JSC::NoIntrinsic;
const char* const s_readableStreamCreateEmptyReadableStreamCode =
"(function () {\n" \
" \"use strict\";\n" \
"\n" \
" var stream = new @ReadableStream({\n" \
" pull() {},\n" \
" });\n" \
@@ -397,18 +405,17 @@ const char* const s_readableStreamCreateEmptyReadableStreamCode =
const JSC::ConstructAbility s_readableStreamCreateNativeReadableStreamCodeConstructAbility = JSC::ConstructAbility::CannotConstruct;
const JSC::ConstructorKind s_readableStreamCreateNativeReadableStreamCodeConstructorKind = JSC::ConstructorKind::None;
const int s_readableStreamCreateNativeReadableStreamCodeLength = 343;
const int s_readableStreamCreateNativeReadableStreamCodeLength = 266;
static const JSC::Intrinsic s_readableStreamCreateNativeReadableStreamCodeIntrinsic = JSC::NoIntrinsic;
const char* const s_readableStreamCreateNativeReadableStreamCode =
"(function (nativePtr, nativeType, autoAllocateChunkSize) {\n" \
" \"use strict\";\n" \
" stream = new @ReadableStream({\n" \
" return new @ReadableStream({\n" \
" @lazy: true,\n" \
" @bunNativeType: nativeType,\n" \
" @bunNativePtr: nativePtr,\n" \
" autoAllocateChunkSize: autoAllocateChunkSize,\n" \
" });\n" \
" @putByIdDirectPrivate(stream, \"bunNativeType\", nativeType);\n" \
" @putByIdDirectPrivate(stream, \"bunNativePtr\", nativePtr);\n" \
" return stream;\n" \
"})\n" \
;
@@ -433,7 +440,7 @@ const char* const s_readableStreamCancelCode =
const JSC::ConstructAbility s_readableStreamGetReaderCodeConstructAbility = JSC::ConstructAbility::CannotConstruct;
const JSC::ConstructorKind s_readableStreamGetReaderCodeConstructorKind = JSC::ConstructorKind::None;
const int s_readableStreamGetReaderCodeLength = 619;
const int s_readableStreamGetReaderCodeLength = 680;
static const JSC::Intrinsic s_readableStreamGetReaderCodeIntrinsic = JSC::NoIntrinsic;
const char* const s_readableStreamGetReaderCode =
"(function (options)\n" \
@@ -447,8 +454,10 @@ const char* const s_readableStreamGetReaderCode =
" if (mode === @undefined) {\n" \
" var start_ = @getByIdDirectPrivate(this, \"start\");\n" \
" if (start_) {\n" \
" start_.@call(this);\n" \
" @putByIdDirectPrivate(this, \"start\", @undefined);\n" \
" start_();\n" \
" }\n" \
" \n" \
" return new @ReadableStreamDefaultReader(this);\n" \
" }\n" \
" //\n" \

46
src/javascript/jsc/bindings/ReadableStreamInternalsBuiltins.cpp
View File

@@ -197,13 +197,11 @@ const char* const s_readableStreamInternalsSetupReadableStreamDefaultControllerC
const JSC::ConstructAbility s_readableStreamInternalsCreateReadableStreamControllerCodeConstructAbility = JSC::ConstructAbility::CannotConstruct;
const JSC::ConstructorKind s_readableStreamInternalsCreateReadableStreamControllerCodeConstructorKind = JSC::ConstructorKind::None;
const int s_readableStreamInternalsCreateReadableStreamControllerCodeLength = 1256;
const int s_readableStreamInternalsCreateReadableStreamControllerCodeLength = 1196;
static const JSC::Intrinsic s_readableStreamInternalsCreateReadableStreamControllerCodeIntrinsic = JSC::NoIntrinsic;
const char* const s_readableStreamInternalsCreateReadableStreamControllerCode =
"(function (underlyingSource, strategy, fromLazy) {\n" \
" if (fromLazy) {\n" \
" @putByIdDirectPrivate(this, \"start\", @undefined);\n" \
" }\n" \
"(function (stream, underlyingSource, strategy) {\n" \
" \"use strict\";\n" \
"\n" \
" const type = underlyingSource.type;\n" \
" const typeString = @toString(type);\n" \
@@ -217,15 +215,15 @@ const char* const s_readableStreamInternalsCreateReadableStreamControllerCode =
" if (strategy.size !== @undefined)\n" \
" @throwRangeError(\"Strategy for a ReadableByteStreamController cannot have a size\");\n" \
"\n" \
" @putByIdDirectPrivate(this, \"readableStreamController\", new @ReadableByteStreamController(this, underlyingSource, strategy.highWaterMark, @isReadableStream));\n" \
" @putByIdDirectPrivate(stream, \"readableStreamController\", new @ReadableByteStreamController(stream, underlyingSource, strategy.highWaterMark, @isReadableStream));\n" \
" } else if (typeString === \"direct\") {\n" \
" var highWaterMark = strategy?.highWaterMark;\n" \
" @initializeArrayBufferStream.@call(this, underlyingSource, highWaterMark); \n" \
" @initializeArrayBufferStream.@call(stream, underlyingSource, highWaterMark); \n" \
" } else if (type === @undefined) {\n" \
" if (strategy.highWaterMark === @undefined)\n" \
" strategy.highWaterMark = 1;\n" \
" \n" \
" @setupReadableStreamDefaultController(this, underlyingSource, strategy.size, strategy.highWaterMark, underlyingSource.start, underlyingSource.pull, underlyingSource.cancel);\n" \
" @setupReadableStreamDefaultController(stream, underlyingSource, strategy.size, strategy.highWaterMark, underlyingSource.start, underlyingSource.pull, underlyingSource.cancel);\n" \
" } else\n" \
" @throwRangeError(\"Invalid type for underlying source\");\n" \
"\n" \
@@ -392,11 +390,13 @@ const char* const s_readableStreamInternalsPipeToDoReadWriteCode =
const JSC::ConstructAbility s_readableStreamInternalsPipeToErrorsMustBePropagatedForwardCodeConstructAbility = JSC::ConstructAbility::CannotConstruct;
const JSC::ConstructorKind s_readableStreamInternalsPipeToErrorsMustBePropagatedForwardCodeConstructorKind = JSC::ConstructorKind::None;
const int s_readableStreamInternalsPipeToErrorsMustBePropagatedForwardCodeLength = 676;
const int s_readableStreamInternalsPipeToErrorsMustBePropagatedForwardCodeLength = 695;
static const JSC::Intrinsic s_readableStreamInternalsPipeToErrorsMustBePropagatedForwardCodeIntrinsic = JSC::NoIntrinsic;
const char* const s_readableStreamInternalsPipeToErrorsMustBePropagatedForwardCode =
"(function (pipeState)\n" \
"{\n" \
" \"use strict\";\n" \
"\n" \
" const action = () => {\n" \
" pipeState.pendingReadPromiseCapability.@resolve.@call(@undefined, false);\n" \
" const error = @getByIdDirectPrivate(pipeState.source, \"storedError\");\n" \
@@ -442,11 +442,12 @@ const char* const s_readableStreamInternalsPipeToErrorsMustBePropagatedBackwardC
const JSC::ConstructAbility s_readableStreamInternalsPipeToClosingMustBePropagatedForwardCodeConstructAbility = JSC::ConstructAbility::CannotConstruct;
const JSC::ConstructorKind s_readableStreamInternalsPipeToClosingMustBePropagatedForwardCodeConstructorKind = JSC::ConstructorKind::None;
const int s_readableStreamInternalsPipeToClosingMustBePropagatedForwardCodeLength = 680;
const int s_readableStreamInternalsPipeToClosingMustBePropagatedForwardCodeLength = 698;
static const JSC::Intrinsic s_readableStreamInternalsPipeToClosingMustBePropagatedForwardCodeIntrinsic = JSC::NoIntrinsic;
const char* const s_readableStreamInternalsPipeToClosingMustBePropagatedForwardCode =
"(function (pipeState)\n" \
"{\n" \
" \"use strict\";\n" \
" const action = () => {\n" \
" pipeState.pendingReadPromiseCapability.@resolve.@call(@undefined, false);\n" \
" const error = @getByIdDirectPrivate(pipeState.source, \"storedError\");\n" \
@@ -466,11 +467,12 @@ const char* const s_readableStreamInternalsPipeToClosingMustBePropagatedForwardC
const JSC::ConstructAbility s_readableStreamInternalsPipeToClosingMustBePropagatedBackwardCodeConstructAbility = JSC::ConstructAbility::CannotConstruct;
const JSC::ConstructorKind s_readableStreamInternalsPipeToClosingMustBePropagatedBackwardCodeConstructorKind = JSC::ConstructorKind::None;
const int s_readableStreamInternalsPipeToClosingMustBePropagatedBackwardCodeLength = 464;
const int s_readableStreamInternalsPipeToClosingMustBePropagatedBackwardCodeLength = 482;
static const JSC::Intrinsic s_readableStreamInternalsPipeToClosingMustBePropagatedBackwardCodeIntrinsic = JSC::NoIntrinsic;
const char* const s_readableStreamInternalsPipeToClosingMustBePropagatedBackwardCode =
"(function (pipeState)\n" \
"{\n" \
" \"use strict\";\n" \
" if (!@writableStreamCloseQueuedOrInFlight(pipeState.destination) && @getByIdDirectPrivate(pipeState.destination, \"state\") !== \"closed\")\n" \
" return;\n" \
"\n" \
@@ -1486,20 +1488,18 @@ const char* const s_readableStreamInternalsReadableStreamDefaultControllerCanClo
const JSC::ConstructAbility s_readableStreamInternalsLazyLoadStreamCodeConstructAbility = JSC::ConstructAbility::CannotConstruct;
const JSC::ConstructorKind s_readableStreamInternalsLazyLoadStreamCodeConstructorKind = JSC::ConstructorKind::None;
const int s_readableStreamInternalsLazyLoadStreamCodeLength = 3053;
const int s_readableStreamInternalsLazyLoadStreamCodeLength = 2853;
static const JSC::Intrinsic s_readableStreamInternalsLazyLoadStreamCodeIntrinsic = JSC::NoIntrinsic;
const char* const s_readableStreamInternalsLazyLoadStreamCode =
"(function (stream, autoAllocateChunkSize) {\n" \
" \"use strict\";\n" \
"\n" \
" @putByIdDirectPrivate(stream, \"start\", @undefined);\n" \
" var bunNativeType = @getByIdDirectPrivate(stream, \"bunNativeType\");\n" \
" var bunNativePtr = @getByIdDirectPrivate(stream, \"bunNativePtr\");\n" \
"\n" \
" var cached = globalThis[globalThis.Symbol.for(\"Bun.nativeReadableStreamPrototype\")] ||= new @Map;\n" \
" var nativeType = @getByIdDirectPrivate(stream, \"bunNativeType\");\n" \
" var nativePtr = @getByIdDirectPrivate(stream, \"bunNativePtr\");\n" \
" var cached = @lazyStreamPrototypeMap;\n" \
" var Prototype = cached.@get(nativeType);\n" \
" if (Prototype === @undefined) {\n" \
" var [pull, start, cancel, setClose, deinit] = globalThis[globalThis.Symbol.for(\"Bun.lazy\")](nativeType);\n" \
" var [pull, start, cancel, setClose, deinit] = @lazyLoad(nativeType);\n" \
" var closer = [false];\n" \
" var handleResult;\n" \
" function handleNativeReadableStreamPromiseResult(val) {\n" \
@@ -1561,26 +1561,22 @@ const char* const s_readableStreamInternalsLazyLoadStreamCode =
" cancel_(reason) {\n" \
" cancel(this, reason);\n" \
" }\n" \
"\n" \
" static deinit = deinit;\n" \
" static registry = new FinalizationRegistry(deinit);\n" \
" }\n" \
" cached.@set(nativeType, Prototype);\n" \
" }\n" \
"\n" \
" //\n" \
" //\n" \
" //\n" \
" const chunkSize = Prototype.startSync(nativePtr, autoAllocateChunkSize);\n" \
"\n" \
" //\n" \
" if (chunkSize === 0) {\n" \
" @readableStreamClose(stream);\n" \
" return;\n" \
" return null;\n" \
" }\n" \
"\n" \
" var instance = new Prototype(nativePtr, chunkSize);\n" \
" Prototype.registry.register(instance, nativePtr);\n" \
" @createReadableStreamController.@call(stream, instance, @undefined, true);\n" \
" return instance;\n" \
"})\n" \
;

33
src/javascript/jsc/bindings/ZigGlobalObject.cpp
View File

@@ -375,6 +375,17 @@ void GlobalObject::setConsole(void* console)
#pragma mark - Globals
JSC_DECLARE_CUSTOM_GETTER(functionLazyLoadStreamProtoypeMap_getter);
JSC_DEFINE_CUSTOM_GETTER(functionLazyLoadStreamProtoypeMap_getter,
(JSC::JSGlobalObject * lexicalGlobalObject, JSC::EncodedJSValue thisValue,
JSC::PropertyName))
{
Zig::GlobalObject* thisObject = JSC::jsCast<Zig::GlobalObject*>(lexicalGlobalObject);
return JSC::JSValue::encode(
thisObject->readableStreamNativeMap());
}
JSC_DECLARE_CUSTOM_GETTER(JSBuffer_getter);
JSC_DEFINE_CUSTOM_GETTER(JSBuffer_getter,
@@ -1667,6 +1678,12 @@ void GlobalObject::finishCreation(VM& vm)
init.set(prototype);
});
m_lazyReadableStreamPrototypeMap.initLater(
[](const JSC::LazyProperty<JSC::JSGlobalObject, JSC::JSMap>::Initializer& init) {
auto* map = JSC::JSMap::create(init.owner, init.vm, init.owner->mapStructure());
init.set(map);
});
m_JSArrayBufferSinkClassStructure.initLater(
[](LazyClassStructure::Initializer& init) {
auto* prototype = createJSSinkPrototype(init.vm, init.global, WebCore::SinkID::ArrayBufferSink);
@@ -1697,7 +1714,7 @@ void GlobalObject::addBuiltinGlobals(JSC::VM& vm)
auto& builtinNames = WebCore::builtinNames(vm);
WTF::Vector<GlobalPropertyInfo> extraStaticGlobals;
extraStaticGlobals.reserveCapacity(28);
extraStaticGlobals.reserveCapacity(29);
JSC::Identifier queueMicrotaskIdentifier = JSC::Identifier::fromString(vm, "queueMicrotask"_s);
extraStaticGlobals.uncheckedAppend(
@@ -1762,10 +1779,16 @@ void GlobalObject::addBuiltinGlobals(JSC::VM& vm)
static NeverDestroyed<const String> BunLazyString(MAKE_STATIC_STRING_IMPL("Bun.lazy"));
JSC::Identifier BunLazyIdentifier = JSC::Identifier::fromUid(vm.symbolRegistry().symbolForKey(BunLazyString));
JSC::JSFunction* lazyLoadFunction = JSC::JSFunction::create(vm, JSC::jsCast<JSC::JSGlobalObject*>(globalObject()), 0,
BunLazyString, functionLazyLoad);
extraStaticGlobals.uncheckedAppend(
GlobalPropertyInfo { BunLazyIdentifier,
JSC::JSFunction::create(vm, JSC::jsCast<JSC::JSGlobalObject*>(globalObject()), 0,
BunLazyString, functionLazyLoad),
lazyLoadFunction,
JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::DontDelete | JSC::PropertyAttribute::Function | 0 });
extraStaticGlobals.uncheckedAppend(
GlobalPropertyInfo { builtinNames.lazyLoadPrivateName(),
lazyLoadFunction,
JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::DontDelete | JSC::PropertyAttribute::Function | 0 });
extraStaticGlobals.uncheckedAppend(GlobalPropertyInfo(builtinNames.makeThisTypeErrorPrivateName(), JSFunction::create(vm, this, 2, String(), makeThisTypeErrorForBuiltins), PropertyAttribute::DontDelete | PropertyAttribute::ReadOnly));
@@ -1804,6 +1827,9 @@ void GlobalObject::addBuiltinGlobals(JSC::VM& vm)
putDirectCustomAccessor(vm, JSC::Identifier::fromString(vm, "URL"_s), JSC::CustomGetterSetter::create(vm, JSDOMURL_getter, nullptr),
JSC::PropertyAttribute::DontDelete | 0);
putDirectCustomAccessor(vm, builtinNames.lazyStreamPrototypeMapPrivateName(), JSC::CustomGetterSetter::create(vm, functionLazyLoadStreamProtoypeMap_getter, nullptr),
JSC::PropertyAttribute::DontDelete | JSC::PropertyAttribute::ReadOnly | 0);
putDirectCustomAccessor(vm, JSC::Identifier::fromString(vm, "URLSearchParams"_s), JSC::CustomGetterSetter::create(vm, JSURLSearchParams_getter, nullptr),
JSC::PropertyAttribute::DontDelete | JSC::PropertyAttribute::ReadOnly);
@@ -2022,6 +2048,7 @@ void GlobalObject::visitChildrenImpl(JSCell* cell, Visitor& visitor)
thisObject->m_JSFFIFunctionStructure.visit(visitor);
thisObject->m_JSArrayBufferSinkClassStructure.visit(visitor);
thisObject->m_JSArrayBufferControllerPrototype.visit(visitor);
thisObject->m_lazyReadableStreamPrototypeMap.visit(visitor);
visitor.append(thisObject->m_readableStreamToArrayBufferResolve);
visitor.append(thisObject->m_readableStreamToText);

2
src/javascript/jsc/bindings/ZigGlobalObject.h
View File

@@ -152,6 +152,7 @@ public:
JSC::JSObject* ArrayBufferSink() { return m_JSArrayBufferSinkClassStructure.constructorInitializedOnMainThread(this); }
JSC::JSValue ArrayBufferSinkPrototype() { return m_JSArrayBufferSinkClassStructure.prototypeInitializedOnMainThread(this); }
JSC::JSValue JSReadableArrayBufferSinkControllerPrototype() { return m_JSArrayBufferControllerPrototype.getInitializedOnMainThread(this); }
JSC::JSMap* readableStreamNativeMap() { return m_lazyReadableStreamPrototypeMap.getInitializedOnMainThread(this); }
void* bunVM() { return m_bunVM; }
bool isThreadLocalDefaultGlobalObject = false;
@@ -177,6 +178,7 @@ private:
LazyClassStructure m_NapiClassStructure;
LazyClassStructure m_JSArrayBufferSinkClassStructure;
LazyProperty<JSGlobalObject, JSObject> m_JSArrayBufferControllerPrototype;
LazyProperty<JSGlobalObject, JSMap> m_lazyReadableStreamPrototypeMap;
DOMGuardedObjectSet m_guardedObjects WTF_GUARDED_BY_LOCK(m_gcLock);
void* m_bunVM;

41
src/javascript/jsc/bindings/builtins/js/ReadableByteStreamInternals.js
View File

@@ -41,7 +41,7 @@ function privateInitializeReadableByteStreamController(stream, underlyingByteSou
@putByIdDirectPrivate(this, "pulling", false);
@readableByteStreamControllerClearPendingPullIntos(this);
@putByIdDirectPrivate(this, "queue", @newQueue());
@putByIdDirectPrivate(this, "started", -1);
@putByIdDirectPrivate(this, "started", 0);
@putByIdDirectPrivate(this, "closeRequested", false);
let hwm = @toNumber(highWaterMark);
@@ -58,38 +58,28 @@ function privateInitializeReadableByteStreamController(stream, underlyingByteSou
@putByIdDirectPrivate(this, "autoAllocateChunkSize", autoAllocateChunkSize);
@putByIdDirectPrivate(this, "pendingPullIntos", @createFIFO());
const controller = this;
@promiseInvokeOrNoopNoCatch(@getByIdDirectPrivate(controller, "underlyingByteSource"), "start", [controller]).@then(() => {
@putByIdDirectPrivate(controller, "started", 1);
@assert(!@getByIdDirectPrivate(controller, "pulling"));
@assert(!@getByIdDirectPrivate(controller, "pullAgain"));
@readableByteStreamControllerCallPullIfNeeded(controller);
}, (error) => {
if (@getByIdDirectPrivate(stream, "state") === @streamReadable)
@readableByteStreamControllerError(controller, error);
});
@putByIdDirectPrivate(this, "cancel", @readableByteStreamControllerCancel);
@putByIdDirectPrivate(this, "pull", @readableByteStreamControllerPull);
if (@getByIdDirectPrivate(underlyingByteSource, "lazy") === true) {
@putByIdDirectPrivate(this, "start", () => @readableStreamByteStreamControllerStart(this));
} else {
@putByIdDirectPrivate(this, "start", @undefined);
@readableStreamByteStreamControllerStart(this);
}
return this;
}
function readableStreamByteStreamControllerStart(controller) {
"use strict";
@putByIdDirectPrivate(controller, "start", @undefined);
if (@getByIdDirectPrivate(controller, "started") !== -1)
return;
@putByIdDirectPrivate(controller, "started", 0);
var stream = @getByIdDirectPrivate(controller, "controlledReadableStream");
return @promiseInvokeOrNoopNoCatch(@getByIdDirectPrivate(controller, "underlyingByteSource"), "start", [controller]).@then(() => {
@putByIdDirectPrivate(controller, "started", 1);
@assert(!@getByIdDirectPrivate(controller, "pulling"));
@assert(!@getByIdDirectPrivate(controller, "pullAgain"));
@readableByteStreamControllerCallPullIfNeeded(controller);
}, (error) => {
var stream = @getByIdDirectPrivate(controller, "controlledReadableStream");
if (stream && @getByIdDirectPrivate(stream, "state") === @streamReadable)
@readableByteStreamControllerError(controller, error);
});
}
@@ -237,8 +227,7 @@ function readableByteStreamControllerPull(controller)
const stream = @getByIdDirectPrivate(controller, "controlledReadableStream");
@assert(@readableStreamHasDefaultReader(stream));
if (@getByIdDirectPrivate(controller, "queue").size > 0) {
if (@getByIdDirectPrivate(controller, "queue").content?.isNotEmpty()) {
const entry = @getByIdDirectPrivate(controller, "queue").content.shift();
@getByIdDirectPrivate(controller, "queue").size -= entry.byteLength;
@readableByteStreamControllerHandleQueueDrain(controller);

33
src/javascript/jsc/bindings/builtins/js/ReadableStream.js
View File

@@ -29,7 +29,7 @@ function initializeReadableStream(underlyingSource, strategy)
"use strict";
if (underlyingSource === @undefined)
underlyingSource = { };
underlyingSource = { @bunNativeType: 0, @bunNativePtr: 0, @lazy: false };
if (strategy === @undefined)
strategy = { };
@@ -49,6 +49,8 @@ function initializeReadableStream(underlyingSource, strategy)
// Initialized with null value to enable distinction with undefined case.
@putByIdDirectPrivate(this, "readableStreamController", null);
@putByIdDirectPrivate(this, "bunNativeType", @getByIdDirectPrivate(underlyingSource, "bunNativeType") ?? 0);
@putByIdDirectPrivate(this, "bunNativePtr", @getByIdDirectPrivate(underlyingSource, "bunNativePtr") ?? 0);
const isDirect = underlyingSource.type === "direct";
// direct streams are always lazy
@@ -65,16 +67,20 @@ function initializeReadableStream(underlyingSource, strategy)
return this;
}
if (isDirect) {
if ("start" in underlyingSource && typeof underlyingSource.start === "function")
@throwTypeError("\"start\" for direct streams are not implemented yet");
@putByIdDirectPrivate(this, "start", () => @createReadableStreamController.@call(this, underlyingSource, strategy, true));
@putByIdDirectPrivate(this, "start", () => @createReadableStreamController(this, underlyingSource, strategy));
} else if (isLazy) {
const autoAllocateChunkSize = underlyingSource.autoAllocateChunkSize;
@putByIdDirectPrivate(this, "start", () => @lazyLoadStream(this, autoAllocateChunkSize));
@putByIdDirectPrivate(this, "start", () => {
const instance = @lazyLoadStream(this, autoAllocateChunkSize);
if (instance) {
@createReadableStreamController(this, instance, strategy);
}
});
} else {
@putByIdDirectPrivate(this, "start", @undefined);
@createReadableStreamController.@call(this, underlyingSource, strategy, false);
@createReadableStreamController(this, underlyingSource, strategy);
}
@@ -327,6 +333,8 @@ function consumeReadableStream(nativePtr, nativeType, inputStream) {
@globalPrivate
function createEmptyReadableStream() {
"use strict";
var stream = new @ReadableStream({
pull() {},
});
@@ -337,13 +345,12 @@ function createEmptyReadableStream() {
@globalPrivate
function createNativeReadableStream(nativePtr, nativeType, autoAllocateChunkSize) {
"use strict";
stream = new @ReadableStream({
return new @ReadableStream({
@lazy: true,
@bunNativeType: nativeType,
@bunNativePtr: nativePtr,
autoAllocateChunkSize: autoAllocateChunkSize,
});
@putByIdDirectPrivate(stream, "bunNativeType", nativeType);
@putByIdDirectPrivate(stream, "bunNativePtr", nativePtr);
return stream;
}
function cancel(reason)
@@ -370,8 +377,10 @@ function getReader(options)
if (mode === @undefined) {
var start_ = @getByIdDirectPrivate(this, "start");
if (start_) {
start_.@call(this);
@putByIdDirectPrivate(this, "start", @undefined);
start_();
}
return new @ReadableStreamDefaultReader(this);
}
// String conversion is required by spec, hence double equals.

36
src/javascript/jsc/bindings/builtins/js/ReadableStreamInternals.js
View File

@@ -143,10 +143,8 @@ function setupReadableStreamDefaultController(stream, underlyingSource, size, hi
}
function createReadableStreamController(underlyingSource, strategy, fromLazy) {
if (fromLazy) {
@putByIdDirectPrivate(this, "start", @undefined);
}
function createReadableStreamController(stream, underlyingSource, strategy) {
"use strict";
const type = underlyingSource.type;
const typeString = @toString(type);
@@ -160,15 +158,15 @@ function createReadableStreamController(underlyingSource, strategy, fromLazy) {
if (strategy.size !== @undefined)
@throwRangeError("Strategy for a ReadableByteStreamController cannot have a size");
@putByIdDirectPrivate(this, "readableStreamController", new @ReadableByteStreamController(this, underlyingSource, strategy.highWaterMark, @isReadableStream));
@putByIdDirectPrivate(stream, "readableStreamController", new @ReadableByteStreamController(stream, underlyingSource, strategy.highWaterMark, @isReadableStream));
} else if (typeString === "direct") {
var highWaterMark = strategy?.highWaterMark;
@initializeArrayBufferStream.@call(this, underlyingSource, highWaterMark);
@initializeArrayBufferStream.@call(stream, underlyingSource, highWaterMark);
} else if (type === @undefined) {
if (strategy.highWaterMark === @undefined)
strategy.highWaterMark = 1;
@setupReadableStreamDefaultController(this, underlyingSource, strategy.size, strategy.highWaterMark, underlyingSource.start, underlyingSource.pull, underlyingSource.cancel);
@setupReadableStreamDefaultController(stream, underlyingSource, strategy.size, strategy.highWaterMark, underlyingSource.start, underlyingSource.pull, underlyingSource.cancel);
} else
@throwRangeError("Invalid type for underlying source");
@@ -313,6 +311,8 @@ function pipeToDoReadWrite(pipeState)
function pipeToErrorsMustBePropagatedForward(pipeState)
{
"use strict";
const action = () => {
pipeState.pendingReadPromiseCapability.@resolve.@call(@undefined, false);
const error = @getByIdDirectPrivate(pipeState.source, "storedError");
@@ -351,6 +351,7 @@ function pipeToErrorsMustBePropagatedBackward(pipeState)
function pipeToClosingMustBePropagatedForward(pipeState)
{
"use strict";
const action = () => {
pipeState.pendingReadPromiseCapability.@resolve.@call(@undefined, false);
const error = @getByIdDirectPrivate(pipeState.source, "storedError");
@@ -369,6 +370,7 @@ function pipeToClosingMustBePropagatedForward(pipeState)
function pipeToClosingMustBePropagatedBackward(pipeState)
{
"use strict";
if (!@writableStreamCloseQueuedOrInFlight(pipeState.destination) && @getByIdDirectPrivate(pipeState.destination, "state") !== "closed")
return;
@@ -1167,14 +1169,12 @@ function readableStreamDefaultControllerCanCloseOrEnqueue(controller)
function lazyLoadStream(stream, autoAllocateChunkSize) {
"use strict";
@putByIdDirectPrivate(stream, "start", @undefined);
var bunNativeType = @getByIdDirectPrivate(stream, "bunNativeType");
var bunNativePtr = @getByIdDirectPrivate(stream, "bunNativePtr");
var cached = globalThis[globalThis.Symbol.for("Bun.nativeReadableStreamPrototype")] ||= new @Map;
var nativeType = @getByIdDirectPrivate(stream, "bunNativeType");
var nativePtr = @getByIdDirectPrivate(stream, "bunNativePtr");
var cached = @lazyStreamPrototypeMap;
var Prototype = cached.@get(nativeType);
if (Prototype === @undefined) {
var [pull, start, cancel, setClose, deinit] = globalThis[globalThis.Symbol.for("Bun.lazy")](nativeType);
var [pull, start, cancel, setClose, deinit] = @lazyLoad(nativeType);
var closer = [false];
var handleResult;
function handleNativeReadableStreamPromiseResult(val) {
@@ -1236,24 +1236,20 @@ function lazyLoadStream(stream, autoAllocateChunkSize) {
cancel_(reason) {
cancel(this, reason);
}
static deinit = deinit;
static registry = new FinalizationRegistry(deinit);
}
cached.@set(nativeType, Prototype);
}
// either returns the chunk size
// or throws an error
// should never return a Promise
const chunkSize = Prototype.startSync(nativePtr, autoAllocateChunkSize);
// empty file, no need for native back-and-forth on this
if (chunkSize === 0) {
@readableStreamClose(stream);
return;
return null;
}
var instance = new Prototype(nativePtr, chunkSize);
Prototype.registry.register(instance, nativePtr);
@createReadableStreamController.@call(stream, instance, @undefined, true);
return instance;
}

2
src/javascript/jsc/bindings/headers-cpp.h
View File

@@ -1,4 +1,4 @@
//-- AUTOGENERATED FILE -- 1655288763
//-- AUTOGENERATED FILE -- 1655351052
// clang-format off
#pragma once

494
src/javascript/jsc/bindings/headers.h
View File

@@ -1,5 +1,5 @@
// clang-format: off
//-- AUTOGENERATED FILE -- 1655288763
//-- AUTOGENERATED FILE -- 1655351052
#pragma once
#include <stddef.h>
@@ -7,11 +7,11 @@
#include <stdbool.h>
#ifdef __cplusplus
#define AUTO_EXTERN_C extern "C"
#define AUTO_EXTERN_C_ZIG extern "C" __attribute__((weak))
#define AUTO_EXTERN_C extern "C"
#define AUTO_EXTERN_C_ZIG extern "C" __attribute__((weak))
#else
#define AUTO_EXTERN_C
#define AUTO_EXTERN_C_ZIG __attribute__((weak))
#define AUTO_EXTERN_C
#define AUTO_EXTERN_C_ZIG __attribute__((weak))
#endif
#define ZIG_DECL AUTO_EXTERN_C_ZIG
#define CPP_DECL AUTO_EXTERN_C
@@ -26,238 +26,283 @@ typedef void* JSClassRef;
#include "JavaScriptCore/JSClassRef.h"
#endif
#include "headers-handwritten.h"
typedef struct bJSC__SourceCode { unsigned char bytes[24]; } bJSC__SourceCode;
typedef char* bJSC__SourceCode_buf;
typedef struct bWTF__URL { unsigned char bytes[40]; } bWTF__URL;
typedef char* bWTF__URL_buf;
typedef struct bJSC__JSModuleRecord { unsigned char bytes[216]; } bJSC__JSModuleRecord;
typedef char* bJSC__JSModuleRecord_buf;
typedef struct bJSC__ThrowScope { unsigned char bytes[8]; } bJSC__ThrowScope;
typedef char* bJSC__ThrowScope_buf;
typedef struct bJSC__PropertyName { unsigned char bytes[8]; } bJSC__PropertyName;
typedef char* bJSC__PropertyName_buf;
typedef struct bJSC__JSFunction { unsigned char bytes[32]; } bJSC__JSFunction;
typedef char* bJSC__JSFunction_buf;
typedef struct bJSC__JSGlobalObject { unsigned char bytes[2312]; } bJSC__JSGlobalObject;
typedef char* bJSC__JSGlobalObject_buf;
typedef struct bJSC__JSCell { unsigned char bytes[8]; } bJSC__JSCell;
typedef char* bJSC__JSCell_buf;
typedef struct bJSC__CatchScope { unsigned char bytes[8]; } bJSC__CatchScope;
typedef char* bJSC__CatchScope_buf;
typedef struct bWTF__String { unsigned char bytes[8]; } bWTF__String;
typedef char* bWTF__String_buf;
typedef struct bWTF__StringView { unsigned char bytes[16]; } bWTF__StringView;
typedef char* bWTF__StringView_buf;
typedef struct bJSC__JSModuleLoader { unsigned char bytes[16]; } bJSC__JSModuleLoader;
typedef char* bJSC__JSModuleLoader_buf;
typedef struct bInspector__ScriptArguments { unsigned char bytes[32]; } bInspector__ScriptArguments;
typedef char* bInspector__ScriptArguments_buf;
typedef struct bJSC__Exception { unsigned char bytes[40]; } bJSC__Exception;
typedef char* bJSC__Exception_buf;
typedef struct bJSC__VM { unsigned char bytes[52168]; } bJSC__VM;
typedef char* bJSC__VM_buf;
typedef struct bJSC__JSString { unsigned char bytes[16]; } bJSC__JSString;
typedef char* bJSC__JSString_buf;
typedef struct bJSC__SourceOrigin { unsigned char bytes[48]; } bJSC__SourceOrigin;
typedef char* bJSC__SourceOrigin_buf;
typedef struct bWTF__ExternalStringImpl { unsigned char bytes[40]; } bWTF__ExternalStringImpl;
typedef char* bWTF__ExternalStringImpl_buf;
typedef struct bJSC__JSInternalPromise { unsigned char bytes[32]; } bJSC__JSInternalPromise;
typedef char* bJSC__JSInternalPromise_buf;
typedef struct bWTF__StringImpl { unsigned char bytes[24]; } bWTF__StringImpl;
typedef char* bWTF__StringImpl_buf;
typedef struct bJSC__JSPromise { unsigned char bytes[32]; } bJSC__JSPromise;
typedef char* bJSC__JSPromise_buf;
typedef struct bJSC__JSObject { unsigned char bytes[16]; } bJSC__JSObject;
typedef char* bJSC__JSObject_buf;
typedef struct bJSC__Identifier { unsigned char bytes[8]; } bJSC__Identifier;
typedef char* bJSC__Identifier_buf;
typedef struct bJSC__SourceCode {
unsigned char bytes[24];
} bJSC__SourceCode;
typedef char* bJSC__SourceCode_buf;
typedef struct bWTF__URL {
unsigned char bytes[40];
} bWTF__URL;
typedef char* bWTF__URL_buf;
typedef struct bJSC__JSModuleRecord {
unsigned char bytes[216];
} bJSC__JSModuleRecord;
typedef char* bJSC__JSModuleRecord_buf;
typedef struct bJSC__ThrowScope {
unsigned char bytes[8];
} bJSC__ThrowScope;
typedef char* bJSC__ThrowScope_buf;
typedef struct bJSC__PropertyName {
unsigned char bytes[8];
} bJSC__PropertyName;
typedef char* bJSC__PropertyName_buf;
typedef struct bJSC__JSFunction {
unsigned char bytes[32];
} bJSC__JSFunction;
typedef char* bJSC__JSFunction_buf;
typedef struct bJSC__JSGlobalObject {
unsigned char bytes[2312];
} bJSC__JSGlobalObject;
typedef char* bJSC__JSGlobalObject_buf;
typedef struct bJSC__JSCell {
unsigned char bytes[8];
} bJSC__JSCell;
typedef char* bJSC__JSCell_buf;
typedef struct bJSC__CatchScope {
unsigned char bytes[8];
} bJSC__CatchScope;
typedef char* bJSC__CatchScope_buf;
typedef struct bWTF__String {
unsigned char bytes[8];
} bWTF__String;
typedef char* bWTF__String_buf;
typedef struct bWTF__StringView {
unsigned char bytes[16];
} bWTF__StringView;
typedef char* bWTF__StringView_buf;
typedef struct bJSC__JSModuleLoader {
unsigned char bytes[16];
} bJSC__JSModuleLoader;
typedef char* bJSC__JSModuleLoader_buf;
typedef struct bInspector__ScriptArguments {
unsigned char bytes[32];
} bInspector__ScriptArguments;
typedef char* bInspector__ScriptArguments_buf;
typedef struct bJSC__Exception {
unsigned char bytes[40];
} bJSC__Exception;
typedef char* bJSC__Exception_buf;
typedef struct bJSC__VM {
unsigned char bytes[52168];
} bJSC__VM;
typedef char* bJSC__VM_buf;
typedef struct bJSC__JSString {
unsigned char bytes[16];
} bJSC__JSString;
typedef char* bJSC__JSString_buf;
typedef struct bJSC__SourceOrigin {
unsigned char bytes[48];
} bJSC__SourceOrigin;
typedef char* bJSC__SourceOrigin_buf;
typedef struct bWTF__ExternalStringImpl {
unsigned char bytes[40];
} bWTF__ExternalStringImpl;
typedef char* bWTF__ExternalStringImpl_buf;
typedef struct bJSC__JSInternalPromise {
unsigned char bytes[32];
} bJSC__JSInternalPromise;
typedef char* bJSC__JSInternalPromise_buf;
typedef struct bWTF__StringImpl {
unsigned char bytes[24];
} bWTF__StringImpl;
typedef char* bWTF__StringImpl_buf;
typedef struct bJSC__JSPromise {
unsigned char bytes[32];
} bJSC__JSPromise;
typedef char* bJSC__JSPromise_buf;
typedef struct bJSC__JSObject {
unsigned char bytes[16];
} bJSC__JSObject;
typedef char* bJSC__JSObject_buf;
typedef struct bJSC__Identifier {
unsigned char bytes[8];
} bJSC__Identifier;
typedef char* bJSC__Identifier_buf;
#ifndef __cplusplus
typedef bJSC__CatchScope JSC__CatchScope; // JSC::CatchScope
typedef struct JSC__GeneratorPrototype JSC__GeneratorPrototype; // JSC::GeneratorPrototype
typedef struct JSC__ArrayIteratorPrototype JSC__ArrayIteratorPrototype; // JSC::ArrayIteratorPrototype
typedef ErrorableResolvedSource ErrorableResolvedSource;
typedef struct JSC__JSPromisePrototype JSC__JSPromisePrototype; // JSC::JSPromisePrototype
typedef ErrorableZigString ErrorableZigString;
typedef bJSC__PropertyName JSC__PropertyName; // JSC::PropertyName
typedef bJSC__JSObject JSC__JSObject; // JSC::JSObject
typedef bWTF__ExternalStringImpl WTF__ExternalStringImpl; // WTF::ExternalStringImpl
typedef struct JSC__AsyncIteratorPrototype JSC__AsyncIteratorPrototype; // JSC::AsyncIteratorPrototype
typedef bJSC__JSModuleLoader JSC__JSModuleLoader; // JSC::JSModuleLoader
typedef struct JSC__AsyncGeneratorPrototype JSC__AsyncGeneratorPrototype; // JSC::AsyncGeneratorPrototype
typedef struct JSC__AsyncGeneratorFunctionPrototype JSC__AsyncGeneratorFunctionPrototype; // JSC::AsyncGeneratorFunctionPrototype
typedef bJSC__Identifier JSC__Identifier; // JSC::Identifier
typedef struct JSC__ArrayPrototype JSC__ArrayPrototype; // JSC::ArrayPrototype
typedef struct Zig__JSMicrotaskCallback Zig__JSMicrotaskCallback; // Zig::JSMicrotaskCallback
typedef bJSC__JSPromise JSC__JSPromise; // JSC::JSPromise
typedef struct JSC__SetIteratorPrototype JSC__SetIteratorPrototype; // JSC::SetIteratorPrototype
typedef SystemError SystemError;
typedef bJSC__JSCell JSC__JSCell; // JSC::JSCell
typedef bJSC__SourceOrigin JSC__SourceOrigin; // JSC::SourceOrigin
typedef Bun__Writable Bun__Writable;
typedef bJSC__JSModuleRecord JSC__JSModuleRecord; // JSC::JSModuleRecord
typedef bWTF__String WTF__String; // WTF::String
typedef bWTF__URL WTF__URL; // WTF::URL
typedef struct JSC__IteratorPrototype JSC__IteratorPrototype; // JSC::IteratorPrototype
typedef bJSC__JSInternalPromise JSC__JSInternalPromise; // JSC::JSInternalPromise
typedef Bun__Readable Bun__Readable;
typedef struct JSC__RegExpPrototype JSC__RegExpPrototype; // JSC::RegExpPrototype
typedef struct JSC__MapIteratorPrototype JSC__MapIteratorPrototype; // JSC::MapIteratorPrototype
typedef struct WebCore__FetchHeaders WebCore__FetchHeaders; // WebCore::FetchHeaders
typedef struct JSC__CallFrame JSC__CallFrame; // JSC::CallFrame
typedef bWTF__StringView WTF__StringView; // WTF::StringView
typedef bJSC__ThrowScope JSC__ThrowScope; // JSC::ThrowScope
typedef bWTF__StringImpl WTF__StringImpl; // WTF::StringImpl
typedef bJSC__VM JSC__VM; // JSC::VM
typedef JSClassRef JSClassRef;
typedef Bun__ArrayBuffer Bun__ArrayBuffer;
typedef bJSC__JSGlobalObject JSC__JSGlobalObject; // JSC::JSGlobalObject
typedef bJSC__JSFunction JSC__JSFunction; // JSC::JSFunction
typedef struct JSC__AsyncFunctionPrototype JSC__AsyncFunctionPrototype; // JSC::AsyncFunctionPrototype
typedef ZigException ZigException;
typedef bJSC__SourceCode JSC__SourceCode; // JSC::SourceCode
typedef struct JSC__BigIntPrototype JSC__BigIntPrototype; // JSC::BigIntPrototype
typedef struct JSC__GeneratorFunctionPrototype JSC__GeneratorFunctionPrototype; // JSC::GeneratorFunctionPrototype
typedef ZigString ZigString;
typedef struct WebCore__DOMURL WebCore__DOMURL; // WebCore::DOMURL
typedef int64_t JSC__JSValue;
typedef struct JSC__FunctionPrototype JSC__FunctionPrototype; // JSC::FunctionPrototype
typedef bInspector__ScriptArguments Inspector__ScriptArguments; // Inspector::ScriptArguments
typedef bJSC__Exception JSC__Exception; // JSC::Exception
typedef bJSC__JSString JSC__JSString; // JSC::JSString
typedef struct JSC__ObjectPrototype JSC__ObjectPrototype; // JSC::ObjectPrototype
typedef struct JSC__StringPrototype JSC__StringPrototype; // JSC::StringPrototype
typedef bJSC__CatchScope JSC__CatchScope; // JSC::CatchScope
typedef struct JSC__GeneratorPrototype JSC__GeneratorPrototype; // JSC::GeneratorPrototype
typedef struct JSC__ArrayIteratorPrototype JSC__ArrayIteratorPrototype; // JSC::ArrayIteratorPrototype
typedef ErrorableResolvedSource ErrorableResolvedSource;
typedef struct JSC__JSPromisePrototype JSC__JSPromisePrototype; // JSC::JSPromisePrototype
typedef ErrorableZigString ErrorableZigString;
typedef bJSC__PropertyName JSC__PropertyName; // JSC::PropertyName
typedef bJSC__JSObject JSC__JSObject; // JSC::JSObject
typedef bWTF__ExternalStringImpl WTF__ExternalStringImpl; // WTF::ExternalStringImpl
typedef struct JSC__AsyncIteratorPrototype JSC__AsyncIteratorPrototype; // JSC::AsyncIteratorPrototype
typedef bJSC__JSModuleLoader JSC__JSModuleLoader; // JSC::JSModuleLoader
typedef struct JSC__AsyncGeneratorPrototype JSC__AsyncGeneratorPrototype; // JSC::AsyncGeneratorPrototype
typedef struct JSC__AsyncGeneratorFunctionPrototype JSC__AsyncGeneratorFunctionPrototype; // JSC::AsyncGeneratorFunctionPrototype
typedef bJSC__Identifier JSC__Identifier; // JSC::Identifier
typedef struct JSC__ArrayPrototype JSC__ArrayPrototype; // JSC::ArrayPrototype
typedef struct Zig__JSMicrotaskCallback Zig__JSMicrotaskCallback; // Zig::JSMicrotaskCallback
typedef bJSC__JSPromise JSC__JSPromise; // JSC::JSPromise
typedef struct JSC__SetIteratorPrototype JSC__SetIteratorPrototype; // JSC::SetIteratorPrototype
typedef SystemError SystemError;
typedef bJSC__JSCell JSC__JSCell; // JSC::JSCell
typedef bJSC__SourceOrigin JSC__SourceOrigin; // JSC::SourceOrigin
typedef Bun__Writable Bun__Writable;
typedef bJSC__JSModuleRecord JSC__JSModuleRecord; // JSC::JSModuleRecord
typedef bWTF__String WTF__String; // WTF::String
typedef bWTF__URL WTF__URL; // WTF::URL
typedef struct JSC__IteratorPrototype JSC__IteratorPrototype; // JSC::IteratorPrototype
typedef bJSC__JSInternalPromise JSC__JSInternalPromise; // JSC::JSInternalPromise
typedef Bun__Readable Bun__Readable;
typedef struct JSC__RegExpPrototype JSC__RegExpPrototype; // JSC::RegExpPrototype
typedef struct JSC__MapIteratorPrototype JSC__MapIteratorPrototype; // JSC::MapIteratorPrototype
typedef struct WebCore__FetchHeaders WebCore__FetchHeaders; // WebCore::FetchHeaders
typedef struct JSC__CallFrame JSC__CallFrame; // JSC::CallFrame
typedef bWTF__StringView WTF__StringView; // WTF::StringView
typedef bJSC__ThrowScope JSC__ThrowScope; // JSC::ThrowScope
typedef bWTF__StringImpl WTF__StringImpl; // WTF::StringImpl
typedef bJSC__VM JSC__VM; // JSC::VM
typedef JSClassRef JSClassRef;
typedef Bun__ArrayBuffer Bun__ArrayBuffer;
typedef bJSC__JSGlobalObject JSC__JSGlobalObject; // JSC::JSGlobalObject
typedef bJSC__JSFunction JSC__JSFunction; // JSC::JSFunction
typedef struct JSC__AsyncFunctionPrototype JSC__AsyncFunctionPrototype; // JSC::AsyncFunctionPrototype
typedef ZigException ZigException;
typedef bJSC__SourceCode JSC__SourceCode; // JSC::SourceCode
typedef struct JSC__BigIntPrototype JSC__BigIntPrototype; // JSC::BigIntPrototype
typedef struct JSC__GeneratorFunctionPrototype JSC__GeneratorFunctionPrototype; // JSC::GeneratorFunctionPrototype
typedef ZigString ZigString;
typedef struct WebCore__DOMURL WebCore__DOMURL; // WebCore::DOMURL
typedef int64_t JSC__JSValue;
typedef struct JSC__FunctionPrototype JSC__FunctionPrototype; // JSC::FunctionPrototype
typedef bInspector__ScriptArguments Inspector__ScriptArguments; // Inspector::ScriptArguments
typedef bJSC__Exception JSC__Exception; // JSC::Exception
typedef bJSC__JSString JSC__JSString; // JSC::JSString
typedef struct JSC__ObjectPrototype JSC__ObjectPrototype; // JSC::ObjectPrototype
typedef struct JSC__StringPrototype JSC__StringPrototype; // JSC::StringPrototype
#endif
#ifdef __cplusplus
namespace JSC {
class JSCell;
class Exception;
class JSPromisePrototype;
class StringPrototype;
class GeneratorFunctionPrototype;
class ArrayPrototype;
class JSString;
class JSObject;
class AsyncIteratorPrototype;
class AsyncGeneratorFunctionPrototype;
class Identifier;
class JSPromise;
class RegExpPrototype;
class AsyncFunctionPrototype;
class CatchScope;
class VM;
class BigIntPrototype;
class SourceOrigin;
class ThrowScope;
class SetIteratorPrototype;
class AsyncGeneratorPrototype;
class PropertyName;
class MapIteratorPrototype;
class JSModuleRecord;
class JSInternalPromise;
class ArrayIteratorPrototype;
class JSFunction;
class JSModuleLoader;
class GeneratorPrototype;
class JSGlobalObject;
class SourceCode;
class FunctionPrototype;
class IteratorPrototype;
class CallFrame;
class ObjectPrototype;
}
namespace WTF {
class URL;
class StringImpl;
class String;
class StringView;
class ExternalStringImpl;
}
namespace Zig {
class JSMicrotaskCallback;
}
namespace WebCore {
class DOMURL;
class FetchHeaders;
}
namespace Inspector {
class ScriptArguments;
}
namespace JSC {
class JSCell;
class Exception;
class JSPromisePrototype;
class StringPrototype;
class GeneratorFunctionPrototype;
class ArrayPrototype;
class JSString;
class JSObject;
class AsyncIteratorPrototype;
class AsyncGeneratorFunctionPrototype;
class Identifier;
class JSPromise;
class RegExpPrototype;
class AsyncFunctionPrototype;
class CatchScope;
class VM;
class BigIntPrototype;
class SourceOrigin;
class ThrowScope;
class SetIteratorPrototype;
class AsyncGeneratorPrototype;
class PropertyName;
class MapIteratorPrototype;
class JSModuleRecord;
class JSInternalPromise;
class ArrayIteratorPrototype;
class JSFunction;
class JSModuleLoader;
class GeneratorPrototype;
class JSGlobalObject;
class SourceCode;
class FunctionPrototype;
class IteratorPrototype;
class CallFrame;
class ObjectPrototype;
}
namespace WTF {
class URL;
class StringImpl;
class String;
class StringView;
class ExternalStringImpl;
}
namespace Zig {
class JSMicrotaskCallback;
}
namespace WebCore {
class DOMURL;
class FetchHeaders;
}
namespace Inspector {
class ScriptArguments;
}
typedef ErrorableResolvedSource ErrorableResolvedSource;
typedef ErrorableZigString ErrorableZigString;
typedef SystemError SystemError;
typedef Bun__Writable Bun__Writable;
typedef Bun__Readable Bun__Readable;
typedef JSClassRef JSClassRef;
typedef Bun__ArrayBuffer Bun__ArrayBuffer;
typedef ZigException ZigException;
typedef ZigString ZigString;
typedef int64_t JSC__JSValue;
using JSC__JSCell = JSC::JSCell;
using JSC__Exception = JSC::Exception;
using JSC__JSPromisePrototype = JSC::JSPromisePrototype;
using JSC__StringPrototype = JSC::StringPrototype;
using JSC__GeneratorFunctionPrototype = JSC::GeneratorFunctionPrototype;
using JSC__ArrayPrototype = JSC::ArrayPrototype;
using JSC__JSString = JSC::JSString;
using JSC__JSObject = JSC::JSObject;
using JSC__AsyncIteratorPrototype = JSC::AsyncIteratorPrototype;
using JSC__AsyncGeneratorFunctionPrototype = JSC::AsyncGeneratorFunctionPrototype;
using JSC__Identifier = JSC::Identifier;
using JSC__JSPromise = JSC::JSPromise;
using JSC__RegExpPrototype = JSC::RegExpPrototype;
using JSC__AsyncFunctionPrototype = JSC::AsyncFunctionPrototype;
using JSC__CatchScope = JSC::CatchScope;
using JSC__VM = JSC::VM;
using JSC__BigIntPrototype = JSC::BigIntPrototype;
using JSC__SourceOrigin = JSC::SourceOrigin;
using JSC__ThrowScope = JSC::ThrowScope;
using JSC__SetIteratorPrototype = JSC::SetIteratorPrototype;
using JSC__AsyncGeneratorPrototype = JSC::AsyncGeneratorPrototype;
using JSC__PropertyName = JSC::PropertyName;
using JSC__MapIteratorPrototype = JSC::MapIteratorPrototype;
using JSC__JSModuleRecord = JSC::JSModuleRecord;
using JSC__JSInternalPromise = JSC::JSInternalPromise;
using JSC__ArrayIteratorPrototype = JSC::ArrayIteratorPrototype;
using JSC__JSFunction = JSC::JSFunction;
using JSC__JSModuleLoader = JSC::JSModuleLoader;
using JSC__GeneratorPrototype = JSC::GeneratorPrototype;
using JSC__JSGlobalObject = JSC::JSGlobalObject;
using JSC__SourceCode = JSC::SourceCode;
using JSC__FunctionPrototype = JSC::FunctionPrototype;
using JSC__IteratorPrototype = JSC::IteratorPrototype;
using JSC__CallFrame = JSC::CallFrame;
using JSC__ObjectPrototype = JSC::ObjectPrototype;
using WTF__URL = WTF::URL;
using WTF__StringImpl = WTF::StringImpl;
using WTF__String = WTF::String;
using WTF__StringView = WTF::StringView;
using WTF__ExternalStringImpl = WTF::ExternalStringImpl;
using Zig__JSMicrotaskCallback = Zig::JSMicrotaskCallback;
using WebCore__DOMURL = WebCore::DOMURL;
using WebCore__FetchHeaders = WebCore::FetchHeaders;
using Inspector__ScriptArguments = Inspector::ScriptArguments;
typedef ErrorableResolvedSource ErrorableResolvedSource;
typedef ErrorableZigString ErrorableZigString;
typedef SystemError SystemError;
typedef Bun__Writable Bun__Writable;
typedef Bun__Readable Bun__Readable;
typedef JSClassRef JSClassRef;
typedef Bun__ArrayBuffer Bun__ArrayBuffer;
typedef ZigException ZigException;
typedef ZigString ZigString;
typedef int64_t JSC__JSValue;
using JSC__JSCell = JSC::JSCell;
using JSC__Exception = JSC::Exception;
using JSC__JSPromisePrototype = JSC::JSPromisePrototype;
using JSC__StringPrototype = JSC::StringPrototype;
using JSC__GeneratorFunctionPrototype = JSC::GeneratorFunctionPrototype;
using JSC__ArrayPrototype = JSC::ArrayPrototype;
using JSC__JSString = JSC::JSString;
using JSC__JSObject = JSC::JSObject;
using JSC__AsyncIteratorPrototype = JSC::AsyncIteratorPrototype;
using JSC__AsyncGeneratorFunctionPrototype = JSC::AsyncGeneratorFunctionPrototype;
using JSC__Identifier = JSC::Identifier;
using JSC__JSPromise = JSC::JSPromise;
using JSC__RegExpPrototype = JSC::RegExpPrototype;
using JSC__AsyncFunctionPrototype = JSC::AsyncFunctionPrototype;
using JSC__CatchScope = JSC::CatchScope;
using JSC__VM = JSC::VM;
using JSC__BigIntPrototype = JSC::BigIntPrototype;
using JSC__SourceOrigin = JSC::SourceOrigin;
using JSC__ThrowScope = JSC::ThrowScope;
using JSC__SetIteratorPrototype = JSC::SetIteratorPrototype;
using JSC__AsyncGeneratorPrototype = JSC::AsyncGeneratorPrototype;
using JSC__PropertyName = JSC::PropertyName;
using JSC__MapIteratorPrototype = JSC::MapIteratorPrototype;
using JSC__JSModuleRecord = JSC::JSModuleRecord;
using JSC__JSInternalPromise = JSC::JSInternalPromise;
using JSC__ArrayIteratorPrototype = JSC::ArrayIteratorPrototype;
using JSC__JSFunction = JSC::JSFunction;
using JSC__JSModuleLoader = JSC::JSModuleLoader;
using JSC__GeneratorPrototype = JSC::GeneratorPrototype;
using JSC__JSGlobalObject = JSC::JSGlobalObject;
using JSC__SourceCode = JSC::SourceCode;
using JSC__FunctionPrototype = JSC::FunctionPrototype;
using JSC__IteratorPrototype = JSC::IteratorPrototype;
using JSC__CallFrame = JSC::CallFrame;
using JSC__ObjectPrototype = JSC::ObjectPrototype;
using WTF__URL = WTF::URL;
using WTF__StringImpl = WTF::StringImpl;
using WTF__String = WTF::String;
using WTF__StringView = WTF::StringView;
using WTF__ExternalStringImpl = WTF::ExternalStringImpl;
using Zig__JSMicrotaskCallback = Zig::JSMicrotaskCallback;
using WebCore__DOMURL = WebCore::DOMURL;
using WebCore__FetchHeaders = WebCore::FetchHeaders;
using Inspector__ScriptArguments = Inspector::ScriptArguments;
#endif
#pragma mark - JSC::JSObject
CPP_DECL JSC__JSValue JSC__JSObject__create(JSC__JSGlobalObject* arg0, size_t arg1, void* arg2, void (* ArgFn3)(void* arg0, JSC__JSObject* arg1, JSC__JSGlobalObject* arg2));
CPP_DECL JSC__JSValue JSC__JSObject__create(JSC__JSGlobalObject* arg0, size_t arg1, void* arg2, void (*ArgFn3)(void* arg0, JSC__JSObject* arg1, JSC__JSGlobalObject* arg2));
CPP_DECL size_t JSC__JSObject__getArrayLength(JSC__JSObject* arg0);
CPP_DECL JSC__JSValue JSC__JSObject__getDirect(JSC__JSObject* arg0, JSC__JSGlobalObject* arg1, const ZigString* arg2);
CPP_DECL JSC__JSValue JSC__JSObject__getIndex(JSC__JSValue JSValue0, JSC__JSGlobalObject* arg1, uint32_t arg2);
CPP_DECL void JSC__JSObject__putRecord(JSC__JSObject* arg0, JSC__JSGlobalObject* arg1, ZigString* arg2, ZigString* arg3, size_t arg4);
CPP_DECL JSC__JSValue ZigString__external(const ZigString* arg0, JSC__JSGlobalObject* arg1, void* arg2, void (* ArgFn3)(void* arg0, void* arg1, size_t arg2));
CPP_DECL JSC__JSValue ZigString__external(const ZigString* arg0, JSC__JSGlobalObject* arg1, void* arg2, void (*ArgFn3)(void* arg0, void* arg1, size_t arg2));
CPP_DECL JSC__JSValue ZigString__to16BitValue(const ZigString* arg0, JSC__JSGlobalObject* arg1);
CPP_DECL JSC__JSValue ZigString__toErrorInstance(const ZigString* arg0, JSC__JSGlobalObject* arg1);
CPP_DECL JSC__JSValue ZigString__toExternalU16(const uint16_t* arg0, size_t arg1, JSC__JSGlobalObject* arg2);
CPP_DECL JSC__JSValue ZigString__toExternalValue(const ZigString* arg0, JSC__JSGlobalObject* arg1);
CPP_DECL JSC__JSValue ZigString__toExternalValueWithCallback(const ZigString* arg0, JSC__JSGlobalObject* arg1, void (* ArgFn2)(void* arg0, void* arg1, size_t arg2));
CPP_DECL JSC__JSValue ZigString__toExternalValueWithCallback(const ZigString* arg0, JSC__JSGlobalObject* arg1, void (*ArgFn2)(void* arg0, void* arg1, size_t arg2));
CPP_DECL JSC__JSValue ZigString__toValue(const ZigString* arg0, JSC__JSGlobalObject* arg1);
CPP_DECL JSC__JSValue ZigString__toValueGC(const ZigString* arg0, JSC__JSGlobalObject* arg1);
CPP_DECL WebCore__DOMURL* WebCore__DOMURL__cast_(JSC__JSValue JSValue0, JSC__VM* arg1);
@@ -399,6 +444,7 @@ CPP_DECL JSC__JSPromisePrototype* JSC__JSGlobalObject__promisePrototype(JSC__JSG
CPP_DECL JSC__JSValue JSC__JSGlobalObject__putCachedObject(JSC__JSGlobalObject* arg0, const ZigString* arg1, JSC__JSValue JSValue2);
CPP_DECL JSC__RegExpPrototype* JSC__JSGlobalObject__regExpPrototype(JSC__JSGlobalObject* arg0);
CPP_DECL JSC__SetIteratorPrototype* JSC__JSGlobalObject__setIteratorPrototype(JSC__JSGlobalObject* arg0);
CPP_DECL bool JSC__JSGlobalObject__startRemoteInspector(JSC__JSGlobalObject* arg0, unsigned char* arg1, uint16_t arg2);
CPP_DECL JSC__StringPrototype* JSC__JSGlobalObject__stringPrototype(JSC__JSGlobalObject* arg0);
CPP_DECL JSC__JSObject* JSC__JSGlobalObject__symbolPrototype(JSC__JSGlobalObject* arg0);
CPP_DECL JSC__VM* JSC__JSGlobalObject__vm(JSC__JSGlobalObject* arg0);
@@ -453,7 +499,7 @@ CPP_DECL size_t WTF__String__length(WTF__String* arg0);
#pragma mark - JSC::JSValue
CPP_DECL void JSC__JSValue___then(JSC__JSValue JSValue0, JSC__JSGlobalObject* arg1, void* arg2, void (* ArgFn3)(JSC__JSGlobalObject* arg0, void* arg1, void** arg2, size_t arg3), void (* ArgFn4)(JSC__JSGlobalObject* arg0, void* arg1, void** arg2, size_t arg3));
CPP_DECL void JSC__JSValue___then(JSC__JSValue JSValue0, JSC__JSGlobalObject* arg1, void* arg2, void (*ArgFn3)(JSC__JSGlobalObject* arg0, void* arg1, void** arg2, size_t arg3), void (*ArgFn4)(JSC__JSGlobalObject* arg0, void* arg1, void** arg2, size_t arg3));
CPP_DECL bool JSC__JSValue__asArrayBuffer_(JSC__JSValue JSValue0, JSC__JSGlobalObject* arg1, Bun__ArrayBuffer* arg2);
CPP_DECL JSC__JSCell* JSC__JSValue__asCell(JSC__JSValue JSValue0);
CPP_DECL JSC__JSInternalPromise* JSC__JSValue__asInternalPromise(JSC__JSValue JSValue0);
@@ -471,7 +517,7 @@ CPP_DECL JSC__JSValue JSC__JSValue__createTypeError(const ZigString* arg0, const
CPP_DECL JSC__JSValue JSC__JSValue__createUninitializedUint8Array(JSC__JSGlobalObject* arg0, size_t arg1);
CPP_DECL bool JSC__JSValue__eqlCell(JSC__JSValue JSValue0, JSC__JSCell* arg1);
CPP_DECL bool JSC__JSValue__eqlValue(JSC__JSValue JSValue0, JSC__JSValue JSValue1);
CPP_DECL void JSC__JSValue__forEach(JSC__JSValue JSValue0, JSC__JSGlobalObject* arg1, void* arg2, void (* ArgFn3)(JSC__VM* arg0, JSC__JSGlobalObject* arg1, void* arg2, JSC__JSValue JSValue3));
CPP_DECL void JSC__JSValue__forEach(JSC__JSValue JSValue0, JSC__JSGlobalObject* arg1, void* arg2, void (*ArgFn3)(JSC__VM* arg0, JSC__JSGlobalObject* arg1, void* arg2, JSC__JSValue JSValue3));
CPP_DECL JSC__JSValue JSC__JSValue__fromEntries(JSC__JSGlobalObject* arg0, ZigString* arg1, ZigString* arg2, size_t arg3, bool arg4);
CPP_DECL JSC__JSValue JSC__JSValue__fromInt64NoTruncate(JSC__JSGlobalObject* arg0, int64_t arg1);
CPP_DECL JSC__JSValue JSC__JSValue__fromUInt64NoTruncate(JSC__JSGlobalObject* arg0, uint64_t arg1);
@@ -557,13 +603,13 @@ CPP_DECL JSC__JSValue JSC__Exception__value(JSC__Exception* arg0);
CPP_DECL void JSC__VM__clearExecutionTimeLimit(JSC__VM* arg0);
CPP_DECL JSC__VM* JSC__VM__create(unsigned char HeapType0);
CPP_DECL void JSC__VM__deferGC(JSC__VM* arg0, void* arg1, void (* ArgFn2)(void* arg0));
CPP_DECL void JSC__VM__deferGC(JSC__VM* arg0, void* arg1, void (*ArgFn2)(void* arg0));
CPP_DECL void JSC__VM__deinit(JSC__VM* arg0, JSC__JSGlobalObject* arg1);
CPP_DECL void JSC__VM__deleteAllCode(JSC__VM* arg0, JSC__JSGlobalObject* arg1);
CPP_DECL void JSC__VM__doWork(JSC__VM* arg0);
CPP_DECL void JSC__VM__drainMicrotasks(JSC__VM* arg0);
CPP_DECL bool JSC__VM__executionForbidden(JSC__VM* arg0);
CPP_DECL void JSC__VM__holdAPILock(JSC__VM* arg0, void* arg1, void (* ArgFn2)(void* arg0));
CPP_DECL void JSC__VM__holdAPILock(JSC__VM* arg0, void* arg1, void (*ArgFn2)(void* arg0));
CPP_DECL bool JSC__VM__isEntered(JSC__VM* arg0);
CPP_DECL bool JSC__VM__isJITEnabled();
CPP_DECL void JSC__VM__releaseWeakRefs(JSC__VM* arg0);
@@ -573,7 +619,7 @@ CPP_DECL void JSC__VM__setExecutionTimeLimit(JSC__VM* arg0, double arg1);
CPP_DECL void JSC__VM__shrinkFootprint(JSC__VM* arg0);
CPP_DECL void JSC__VM__throwError(JSC__VM* arg0, JSC__JSGlobalObject* arg1, JSC__JSValue JSValue2);
CPP_DECL void JSC__VM__throwError(JSC__VM* arg0, JSC__JSGlobalObject* arg1, JSC__JSValue JSValue2);
CPP_DECL void JSC__VM__whenIdle(JSC__VM* arg0, void (* ArgFn1)());
CPP_DECL void JSC__VM__whenIdle(JSC__VM* arg0, void (*ArgFn1)());
#pragma mark - JSC::ThrowScope
@@ -620,7 +666,7 @@ CPP_DECL size_t WTF__StringImpl__length(const WTF__StringImpl* arg0);
CPP_DECL const uint16_t* WTF__ExternalStringImpl__characters16(const WTF__ExternalStringImpl* arg0);
CPP_DECL const unsigned char* WTF__ExternalStringImpl__characters8(const WTF__ExternalStringImpl* arg0);
CPP_DECL bWTF__ExternalStringImpl WTF__ExternalStringImpl__create(const unsigned char* arg0, size_t arg1, void (* ArgFn2)(void* arg0, unsigned char* arg1, size_t arg2));
CPP_DECL bWTF__ExternalStringImpl WTF__ExternalStringImpl__create(const unsigned char* arg0, size_t arg1, void (*ArgFn2)(void* arg0, unsigned char* arg1, size_t arg2));
CPP_DECL bool WTF__ExternalStringImpl__is16Bit(const WTF__ExternalStringImpl* arg0);
CPP_DECL bool WTF__ExternalStringImpl__is8Bit(const WTF__ExternalStringImpl* arg0);
CPP_DECL bool WTF__ExternalStringImpl__isEmpty(const WTF__ExternalStringImpl* arg0);
@@ -758,7 +804,6 @@ CPP_DECL ZigException ZigException__fromException(JSC__Exception* arg0);
#pragma mark - Zig::ConsoleClient
#ifdef __cplusplus
ZIG_DECL void Zig__ConsoleClient__count(void* arg0, JSC__JSGlobalObject* arg1, const unsigned char* arg2, size_t arg3);
@@ -779,7 +824,6 @@ ZIG_DECL void Zig__ConsoleClient__timeStamp(void* arg0, JSC__JSGlobalObject* arg
#pragma mark - Bun__Timer
#ifdef __cplusplus
ZIG_DECL JSC__JSValue Bun__Timer__clearInterval(JSC__JSGlobalObject* arg0, JSC__JSValue JSValue1);

2
src/javascript/jsc/bindings/headers.zig
View File

@@ -260,6 +260,8 @@ pub extern fn JSC__JSGlobalObject__promisePrototype(arg0: [*c]JSC__JSGlobalObjec
pub extern fn JSC__JSGlobalObject__putCachedObject(arg0: [*c]JSC__JSGlobalObject, arg1: [*c]const ZigString, JSValue2: JSC__JSValue) JSC__JSValue;
pub extern fn JSC__JSGlobalObject__regExpPrototype(arg0: [*c]JSC__JSGlobalObject) ?*JSC__RegExpPrototype;
pub extern fn JSC__JSGlobalObject__setIteratorPrototype(arg0: [*c]JSC__JSGlobalObject) ?*JSC__SetIteratorPrototype;
pub extern fn JSC__JSGlobalObject__startRemoteInspector(arg0: [*c]JSC__JSGlobalObject, arg1: [*c]u8, arg2: u16) bool;
pub extern fn JSC__JSGlobalObject__stopRemoteInspector(arg0: [*c]JSC__JSGlobalObject) void;
pub extern fn JSC__JSGlobalObject__stringPrototype(arg0: [*c]JSC__JSGlobalObject) ?*JSC__StringPrototype;
pub extern fn JSC__JSGlobalObject__symbolPrototype(arg0: [*c]JSC__JSGlobalObject) [*c]JSC__JSObject;
pub extern fn JSC__JSGlobalObject__vm(arg0: [*c]JSC__JSGlobalObject) [*c]JSC__VM;

2
src/javascript/jsc/webcore/streams.zig
View File

@@ -279,7 +279,7 @@ pub const StreamStart = union(Tag) {
empty = false;
}
if (value.get(globalThis, "highwaterMark")) |chunkSize| {
if (value.get(globalThis, "highWaterMark")) |chunkSize| {
empty = false;
chunk_size = @intCast(JSC.WebCore.Blob.SizeType, @maximum(0, @truncate(i51, chunkSize.toInt64())));
}