I like this direction

Former-commit-id: 3a95a74b7f

src/javascript/jsc/JavascriptCore.zig

@@ -0,0 +1,238 @@
+pub const struct_OpaqueJSContextGroup = opaque {};
+pub const JSContextGroupRef = ?*const struct_OpaqueJSContextGroup;
+pub const struct_OpaqueJSContext = opaque {};
+pub const JSContextRef = ?*const struct_OpaqueJSContext;
+pub const JSGlobalContextRef = ?*struct_OpaqueJSContext;
+pub const struct_OpaqueJSString = opaque {};
+pub const JSStringRef = ?*struct_OpaqueJSString;
+pub const struct_OpaqueJSClass = opaque {};
+pub const JSClassRef = ?*struct_OpaqueJSClass;
+pub const struct_OpaqueJSPropertyNameArray = opaque {};
+pub const JSPropertyNameArrayRef = ?*struct_OpaqueJSPropertyNameArray;
+pub const struct_OpaqueJSPropertyNameAccumulator = opaque {};
+pub const JSPropertyNameAccumulatorRef = ?*struct_OpaqueJSPropertyNameAccumulator;
+pub const JSTypedArrayBytesDeallocator = ?fn (?*c_void, ?*c_void) callconv(.C) void;
+pub const struct_OpaqueJSValue = opaque {};
+pub const JSValueRef = ?*const struct_OpaqueJSValue;
+pub const JSObjectRef = ?*struct_OpaqueJSValue;
+pub extern fn JSEvaluateScript(ctx: JSContextRef, script: JSStringRef, thisObject: JSObjectRef, sourceURL: JSStringRef, startingLineNumber: c_int, exception: [*c]JSValueRef) JSValueRef;
+pub extern fn JSCheckScriptSyntax(ctx: JSContextRef, script: JSStringRef, sourceURL: JSStringRef, startingLineNumber: c_int, exception: [*c]JSValueRef) bool;
+pub extern fn JSGarbageCollect(ctx: JSContextRef) void;
+pub const JSType = enum(c_uint) {
+    kJSTypeUndefined,
+    kJSTypeNull,
+    kJSTypeBoolean,
+    kJSTypeNumber,
+    kJSTypeString,
+    kJSTypeObject,
+    kJSTypeSymbol,
+    _,
+};
+pub const kJSTypeUndefined = @enumToInt(JSType.kJSTypeUndefined);
+pub const kJSTypeNull = @enumToInt(JSType.kJSTypeNull);
+pub const kJSTypeBoolean = @enumToInt(JSType.kJSTypeBoolean);
+pub const kJSTypeNumber = @enumToInt(JSType.kJSTypeNumber);
+pub const kJSTypeString = @enumToInt(JSType.kJSTypeString);
+pub const kJSTypeObject = @enumToInt(JSType.kJSTypeObject);
+pub const kJSTypeSymbol = @enumToInt(JSType.kJSTypeSymbol);
+pub const JSTypedArrayType = enum(c_uint) {
+    kJSTypedArrayTypeInt8Array,
+    kJSTypedArrayTypeInt16Array,
+    kJSTypedArrayTypeInt32Array,
+    kJSTypedArrayTypeUint8Array,
+    kJSTypedArrayTypeUint8ClampedArray,
+    kJSTypedArrayTypeUint16Array,
+    kJSTypedArrayTypeUint32Array,
+    kJSTypedArrayTypeFloat32Array,
+    kJSTypedArrayTypeFloat64Array,
+    kJSTypedArrayTypeArrayBuffer,
+    kJSTypedArrayTypeNone,
+    _,
+};
+pub const kJSTypedArrayTypeInt8Array = @enumToInt(JSTypedArrayType.kJSTypedArrayTypeInt8Array);
+pub const kJSTypedArrayTypeInt16Array = @enumToInt(JSTypedArrayType.kJSTypedArrayTypeInt16Array);
+pub const kJSTypedArrayTypeInt32Array = @enumToInt(JSTypedArrayType.kJSTypedArrayTypeInt32Array);
+pub const kJSTypedArrayTypeUint8Array = @enumToInt(JSTypedArrayType.kJSTypedArrayTypeUint8Array);
+pub const kJSTypedArrayTypeUint8ClampedArray = @enumToInt(JSTypedArrayType.kJSTypedArrayTypeUint8ClampedArray);
+pub const kJSTypedArrayTypeUint16Array = @enumToInt(JSTypedArrayType.kJSTypedArrayTypeUint16Array);
+pub const kJSTypedArrayTypeUint32Array = @enumToInt(JSTypedArrayType.kJSTypedArrayTypeUint32Array);
+pub const kJSTypedArrayTypeFloat32Array = @enumToInt(JSTypedArrayType.kJSTypedArrayTypeFloat32Array);
+pub const kJSTypedArrayTypeFloat64Array = @enumToInt(JSTypedArrayType.kJSTypedArrayTypeFloat64Array);
+pub const kJSTypedArrayTypeArrayBuffer = @enumToInt(JSTypedArrayType.kJSTypedArrayTypeArrayBuffer);
+pub const kJSTypedArrayTypeNone = @enumToInt(JSTypedArrayType.kJSTypedArrayTypeNone);
+pub extern fn JSValueGetType(ctx: JSContextRef, value: JSValueRef) JSType;
+pub extern fn JSValueIsUndefined(ctx: JSContextRef, value: JSValueRef) bool;
+pub extern fn JSValueIsNull(ctx: JSContextRef, value: JSValueRef) bool;
+pub extern fn JSValueIsBoolean(ctx: JSContextRef, value: JSValueRef) bool;
+pub extern fn JSValueIsNumber(ctx: JSContextRef, value: JSValueRef) bool;
+pub extern fn JSValueIsString(ctx: JSContextRef, value: JSValueRef) bool;
+pub extern fn JSValueIsSymbol(ctx: JSContextRef, value: JSValueRef) bool;
+pub extern fn JSValueIsObject(ctx: JSContextRef, value: JSValueRef) bool;
+pub extern fn JSValueIsObjectOfClass(ctx: JSContextRef, value: JSValueRef, jsClass: JSClassRef) bool;
+pub extern fn JSValueIsArray(ctx: JSContextRef, value: JSValueRef) bool;
+pub extern fn JSValueIsDate(ctx: JSContextRef, value: JSValueRef) bool;
+pub extern fn JSValueGetTypedArrayType(ctx: JSContextRef, value: JSValueRef, exception: [*c]JSValueRef) JSTypedArrayType;
+pub extern fn JSValueIsEqual(ctx: JSContextRef, a: JSValueRef, b: JSValueRef, exception: [*c]JSValueRef) bool;
+pub extern fn JSValueIsStrictEqual(ctx: JSContextRef, a: JSValueRef, b: JSValueRef) bool;
+pub extern fn JSValueIsInstanceOfConstructor(ctx: JSContextRef, value: JSValueRef, constructor: JSObjectRef, exception: [*c]JSValueRef) bool;
+pub extern fn JSValueMakeUndefined(ctx: JSContextRef) JSValueRef;
+pub extern fn JSValueMakeNull(ctx: JSContextRef) JSValueRef;
+pub extern fn JSValueMakeBoolean(ctx: JSContextRef, boolean: bool) JSValueRef;
+pub extern fn JSValueMakeNumber(ctx: JSContextRef, number: f64) JSValueRef;
+pub extern fn JSValueMakeString(ctx: JSContextRef, string: JSStringRef) JSValueRef;
+pub extern fn JSValueMakeSymbol(ctx: JSContextRef, description: JSStringRef) JSValueRef;
+pub extern fn JSValueMakeFromJSONString(ctx: JSContextRef, string: JSStringRef) JSValueRef;
+pub extern fn JSValueCreateJSONString(ctx: JSContextRef, value: JSValueRef, indent: c_uint, exception: [*c]JSValueRef) JSStringRef;
+pub extern fn JSValueToBoolean(ctx: JSContextRef, value: JSValueRef) bool;
+pub extern fn JSValueToNumber(ctx: JSContextRef, value: JSValueRef, exception: [*c]JSValueRef) f64;
+pub extern fn JSValueToStringCopy(ctx: JSContextRef, value: JSValueRef, exception: [*c]JSValueRef) JSStringRef;
+pub extern fn JSValueToObject(ctx: JSContextRef, value: JSValueRef, exception: [*c]JSValueRef) JSObjectRef;
+pub extern fn JSValueProtect(ctx: JSContextRef, value: JSValueRef) void;
+pub extern fn JSValueUnprotect(ctx: JSContextRef, value: JSValueRef) void;
+pub const JSPropertyAttributes = enum(c_uint) {
+    kJSPropertyAttributeNone = 0,
+    kJSPropertyAttributeReadOnly = 2,
+    kJSPropertyAttributeDontEnum = 4,
+    kJSPropertyAttributeDontDelete = 8,
+    _,
+};
+pub const kJSPropertyAttributeNone = @enumToInt(JSPropertyAttributes.kJSPropertyAttributeNone);
+pub const kJSPropertyAttributeReadOnly = @enumToInt(JSPropertyAttributes.kJSPropertyAttributeReadOnly);
+pub const kJSPropertyAttributeDontEnum = @enumToInt(JSPropertyAttributes.kJSPropertyAttributeDontEnum);
+pub const kJSPropertyAttributeDontDelete = @enumToInt(JSPropertyAttributes.kJSPropertyAttributeDontDelete);
+pub const JSClassAttributes = enum(c_uint) {
+    kJSClassAttributeNone = 0,
+    kJSClassAttributeNoAutomaticPrototype = 2,
+    _,
+};
+
+pub const kJSClassAttributeNone = @enumToInt(JSClassAttributes.kJSClassAttributeNone);
+pub const kJSClassAttributeNoAutomaticPrototype = @enumToInt(JSClassAttributes.kJSClassAttributeNoAutomaticPrototype);
+pub const JSObjectInitializeCallback = ?fn (JSContextRef, JSObjectRef) callconv(.C) void;
+pub const JSObjectFinalizeCallback = ?fn (JSObjectRef) callconv(.C) void;
+pub const JSObjectHasPropertyCallback = ?fn (JSContextRef, JSObjectRef, JSStringRef) callconv(.C) bool;
+pub const JSObjectGetPropertyCallback = ?fn (JSContextRef, JSObjectRef, JSStringRef, [*c]JSValueRef) callconv(.C) JSValueRef;
+pub const JSObjectSetPropertyCallback = ?fn (JSContextRef, JSObjectRef, JSStringRef, JSValueRef, [*c]JSValueRef) callconv(.C) bool;
+pub const JSObjectDeletePropertyCallback = ?fn (JSContextRef, JSObjectRef, JSStringRef, [*c]JSValueRef) callconv(.C) bool;
+pub const JSObjectGetPropertyNamesCallback = ?fn (JSContextRef, JSObjectRef, JSPropertyNameAccumulatorRef) callconv(.C) void;
+pub const JSObjectCallAsFunctionCallback = ?fn (ctx: JSContextRef, function: JSObjectRef, thisObject: JSObjectRef, argumentCount: usize, arguments: [*c]const JSValueRef, exception: [*c]JSValueRef) callconv(.C) JSValueRef;
+pub const JSObjectCallAsConstructorCallback = ?fn (JSContextRef, JSObjectRef, usize, [*c]const JSValueRef, [*c]JSValueRef) callconv(.C) JSObjectRef;
+pub const JSObjectHasInstanceCallback = ?fn (JSContextRef, JSObjectRef, JSValueRef, [*c]JSValueRef) callconv(.C) bool;
+pub const JSObjectConvertToTypeCallback = ?fn (JSContextRef, JSObjectRef, JSType, [*c]JSValueRef) callconv(.C) JSValueRef;
+pub const JSStaticValue = extern struct {
+    name: [*c]const u8,
+    getProperty: JSObjectGetPropertyCallback,
+    setProperty: JSObjectSetPropertyCallback,
+    attributes: JSPropertyAttributes,
+};
+pub const JSStaticFunction = extern struct {
+    name: [*c]const u8,
+    callAsFunction: JSObjectCallAsFunctionCallback,
+    attributes: JSPropertyAttributes,
+};
+pub const JSClassDefinition = extern struct {
+    version: c_int,
+    attributes: JSClassAttributes,
+    className: [*c]const u8,
+    parentClass: JSClassRef,
+    staticValues: [*c]const JSStaticValue,
+    staticFunctions: [*c]const JSStaticFunction,
+    initialize: JSObjectInitializeCallback,
+    finalize: JSObjectFinalizeCallback,
+    hasProperty: JSObjectHasPropertyCallback,
+    getProperty: JSObjectGetPropertyCallback,
+    setProperty: JSObjectSetPropertyCallback,
+    deleteProperty: JSObjectDeletePropertyCallback,
+    getPropertyNames: JSObjectGetPropertyNamesCallback,
+    callAsFunction: JSObjectCallAsFunctionCallback,
+    callAsConstructor: JSObjectCallAsConstructorCallback,
+    hasInstance: JSObjectHasInstanceCallback,
+    convertToType: JSObjectConvertToTypeCallback,
+};
+pub extern const kJSClassDefinitionEmpty: JSClassDefinition;
+pub extern fn JSClassCreate(definition: [*c]const JSClassDefinition) JSClassRef;
+pub extern fn JSClassRetain(jsClass: JSClassRef) JSClassRef;
+pub extern fn JSClassRelease(jsClass: JSClassRef) void;
+pub extern fn JSObjectMake(ctx: JSContextRef, jsClass: JSClassRef, data: ?*c_void) JSObjectRef;
+pub extern fn JSObjectMakeFunctionWithCallback(ctx: JSContextRef, name: JSStringRef, callAsFunction: JSObjectCallAsFunctionCallback) JSObjectRef;
+pub extern fn JSObjectMakeConstructor(ctx: JSContextRef, jsClass: JSClassRef, callAsConstructor: JSObjectCallAsConstructorCallback) JSObjectRef;
+pub extern fn JSObjectMakeArray(ctx: JSContextRef, argumentCount: usize, arguments: [*c]const JSValueRef, exception: [*c]JSValueRef) JSObjectRef;
+pub extern fn JSObjectMakeDate(ctx: JSContextRef, argumentCount: usize, arguments: [*c]const JSValueRef, exception: [*c]JSValueRef) JSObjectRef;
+pub extern fn JSObjectMakeError(ctx: JSContextRef, argumentCount: usize, arguments: [*c]const JSValueRef, exception: [*c]JSValueRef) JSObjectRef;
+pub extern fn JSObjectMakeRegExp(ctx: JSContextRef, argumentCount: usize, arguments: [*c]const JSValueRef, exception: [*c]JSValueRef) JSObjectRef;
+pub extern fn JSObjectMakeDeferredPromise(ctx: JSContextRef, resolve: [*c]JSObjectRef, reject: [*c]JSObjectRef, exception: [*c]JSValueRef) JSObjectRef;
+pub extern fn JSObjectMakeFunction(ctx: JSContextRef, name: JSStringRef, parameterCount: c_uint, parameterNames: [*c]const JSStringRef, body: JSStringRef, sourceURL: JSStringRef, startingLineNumber: c_int, exception: [*c]JSValueRef) JSObjectRef;
+pub extern fn JSObjectGetPrototype(ctx: JSContextRef, object: JSObjectRef) JSValueRef;
+pub extern fn JSObjectSetPrototype(ctx: JSContextRef, object: JSObjectRef, value: JSValueRef) void;
+pub extern fn JSObjectHasProperty(ctx: JSContextRef, object: JSObjectRef, propertyName: JSStringRef) bool;
+pub extern fn JSObjectGetProperty(ctx: JSContextRef, object: JSObjectRef, propertyName: JSStringRef, exception: [*c]JSValueRef) JSValueRef;
+pub extern fn JSObjectSetProperty(ctx: JSContextRef, object: JSObjectRef, propertyName: JSStringRef, value: JSValueRef, attributes: JSPropertyAttributes, exception: [*c]JSValueRef) void;
+pub extern fn JSObjectDeleteProperty(ctx: JSContextRef, object: JSObjectRef, propertyName: JSStringRef, exception: [*c]JSValueRef) bool;
+pub extern fn JSObjectHasPropertyForKey(ctx: JSContextRef, object: JSObjectRef, propertyKey: JSValueRef, exception: [*c]JSValueRef) bool;
+pub extern fn JSObjectGetPropertyForKey(ctx: JSContextRef, object: JSObjectRef, propertyKey: JSValueRef, exception: [*c]JSValueRef) JSValueRef;
+pub extern fn JSObjectSetPropertyForKey(ctx: JSContextRef, object: JSObjectRef, propertyKey: JSValueRef, value: JSValueRef, attributes: JSPropertyAttributes, exception: [*c]JSValueRef) void;
+pub extern fn JSObjectDeletePropertyForKey(ctx: JSContextRef, object: JSObjectRef, propertyKey: JSValueRef, exception: [*c]JSValueRef) bool;
+pub extern fn JSObjectGetPropertyAtIndex(ctx: JSContextRef, object: JSObjectRef, propertyIndex: c_uint, exception: [*c]JSValueRef) JSValueRef;
+pub extern fn JSObjectSetPropertyAtIndex(ctx: JSContextRef, object: JSObjectRef, propertyIndex: c_uint, value: JSValueRef, exception: [*c]JSValueRef) void;
+pub extern fn JSObjectGetPrivate(object: JSObjectRef) ?*c_void;
+pub extern fn JSObjectSetPrivate(object: JSObjectRef, data: ?*c_void) bool;
+pub extern fn JSObjectIsFunction(ctx: JSContextRef, object: JSObjectRef) bool;
+pub extern fn JSObjectCallAsFunction(ctx: JSContextRef, object: JSObjectRef, thisObject: JSObjectRef, argumentCount: usize, arguments: [*c]const JSValueRef, exception: [*c]JSValueRef) JSValueRef;
+pub extern fn JSObjectIsConstructor(ctx: JSContextRef, object: JSObjectRef) bool;
+pub extern fn JSObjectCallAsConstructor(ctx: JSContextRef, object: JSObjectRef, argumentCount: usize, arguments: [*c]const JSValueRef, exception: [*c]JSValueRef) JSObjectRef;
+pub extern fn JSObjectCopyPropertyNames(ctx: JSContextRef, object: JSObjectRef) JSPropertyNameArrayRef;
+pub extern fn JSPropertyNameArrayRetain(array: JSPropertyNameArrayRef) JSPropertyNameArrayRef;
+pub extern fn JSPropertyNameArrayRelease(array: JSPropertyNameArrayRef) void;
+pub extern fn JSPropertyNameArrayGetCount(array: JSPropertyNameArrayRef) usize;
+pub extern fn JSPropertyNameArrayGetNameAtIndex(array: JSPropertyNameArrayRef, index: usize) JSStringRef;
+pub extern fn JSPropertyNameAccumulatorAddName(accumulator: JSPropertyNameAccumulatorRef, propertyName: JSStringRef) void;
+pub extern fn JSContextGroupCreate() JSContextGroupRef;
+pub extern fn JSContextGroupRetain(group: JSContextGroupRef) JSContextGroupRef;
+pub extern fn JSContextGroupRelease(group: JSContextGroupRef) void;
+pub extern fn JSGlobalContextCreate(globalObjectClass: JSClassRef) JSGlobalContextRef;
+pub extern fn JSGlobalContextCreateInGroup(group: JSContextGroupRef, globalObjectClass: JSClassRef) JSGlobalContextRef;
+pub extern fn JSGlobalContextRetain(ctx: JSGlobalContextRef) JSGlobalContextRef;
+pub extern fn JSGlobalContextRelease(ctx: JSGlobalContextRef) void;
+pub extern fn JSContextGetGlobalObject(ctx: JSContextRef) JSObjectRef;
+pub extern fn JSContextGetGroup(ctx: JSContextRef) JSContextGroupRef;
+pub extern fn JSContextGetGlobalContext(ctx: JSContextRef) JSGlobalContextRef;
+pub extern fn JSGlobalContextCopyName(ctx: JSGlobalContextRef) JSStringRef;
+pub extern fn JSGlobalContextSetName(ctx: JSGlobalContextRef, name: JSStringRef) void;
+pub const JSChar = c_ushort;
+pub extern fn JSStringCreateWithCharacters(chars: [*c]const JSChar, numChars: usize) JSStringRef;
+pub extern fn JSStringCreateWithUTF8CString(string: [*c]const u8) JSStringRef;
+pub extern fn JSStringRetain(string: JSStringRef) JSStringRef;
+pub extern fn JSStringRelease(string: JSStringRef) void;
+pub extern fn JSStringGetLength(string: JSStringRef) usize;
+pub extern fn JSStringGetCharactersPtr(string: JSStringRef) [*c]const JSChar;
+pub extern fn JSStringGetMaximumUTF8CStringSize(string: JSStringRef) usize;
+pub extern fn JSStringGetUTF8CString(string: JSStringRef, buffer: [*c]u8, bufferSize: usize) usize;
+pub extern fn JSStringIsEqual(a: JSStringRef, b: JSStringRef) bool;
+pub extern fn JSStringIsEqualToUTF8CString(a: JSStringRef, b: [*c]const u8) bool;
+pub extern fn JSObjectMakeTypedArray(ctx: JSContextRef, arrayType: JSTypedArrayType, length: usize, exception: [*c]JSValueRef) JSObjectRef;
+pub extern fn JSObjectMakeTypedArrayWithBytesNoCopy(ctx: JSContextRef, arrayType: JSTypedArrayType, bytes: ?*c_void, byteLength: usize, bytesDeallocator: JSTypedArrayBytesDeallocator, deallocatorContext: ?*c_void, exception: [*c]JSValueRef) JSObjectRef;
+pub extern fn JSObjectMakeTypedArrayWithArrayBuffer(ctx: JSContextRef, arrayType: JSTypedArrayType, buffer: JSObjectRef, exception: [*c]JSValueRef) JSObjectRef;
+pub extern fn JSObjectMakeTypedArrayWithArrayBufferAndOffset(ctx: JSContextRef, arrayType: JSTypedArrayType, buffer: JSObjectRef, byteOffset: usize, length: usize, exception: [*c]JSValueRef) JSObjectRef;
+pub extern fn JSObjectGetTypedArrayBytesPtr(ctx: JSContextRef, object: JSObjectRef, exception: [*c]JSValueRef) ?*c_void;
+pub extern fn JSObjectGetTypedArrayLength(ctx: JSContextRef, object: JSObjectRef, exception: [*c]JSValueRef) usize;
+pub extern fn JSObjectGetTypedArrayByteLength(ctx: JSContextRef, object: JSObjectRef, exception: [*c]JSValueRef) usize;
+pub extern fn JSObjectGetTypedArrayByteOffset(ctx: JSContextRef, object: JSObjectRef, exception: [*c]JSValueRef) usize;
+pub extern fn JSObjectGetTypedArrayBuffer(ctx: JSContextRef, object: JSObjectRef, exception: [*c]JSValueRef) JSObjectRef;
+pub extern fn JSObjectMakeArrayBufferWithBytesNoCopy(ctx: JSContextRef, bytes: ?*c_void, byteLength: usize, bytesDeallocator: JSTypedArrayBytesDeallocator, deallocatorContext: ?*c_void, exception: [*c]JSValueRef) JSObjectRef;
+pub extern fn JSObjectGetArrayBufferBytesPtr(ctx: JSContextRef, object: JSObjectRef, exception: [*c]JSValueRef) ?*c_void;
+pub extern fn JSObjectGetArrayBufferByteLength(ctx: JSContextRef, object: JSObjectRef, exception: [*c]JSValueRef) usize;
+pub extern fn JSStringCreateWithCFString(string: CFStringRef) JSStringRef;
+pub const OpaqueJSContextGroup = struct_OpaqueJSContextGroup;
+pub const OpaqueJSContext = struct_OpaqueJSContext;
+pub const OpaqueJSString = struct_OpaqueJSString;
+pub const OpaqueJSClass = struct_OpaqueJSClass;
+pub const OpaqueJSPropertyNameArray = struct_OpaqueJSPropertyNameArray;
+pub const OpaqueJSPropertyNameAccumulator = struct_OpaqueJSPropertyNameAccumulator;
+pub const OpaqueJSValue = struct_OpaqueJSValue;
+
+// -- Manual --
+
+// StringImpl::createWithoutCopying
+// https://github.com/WebKit/webkit/blob/main/Source/JavaScriptCore/API/JSStringRef.cpp#L62
+pub extern fn JSStringCreateWithCharactersNoCopy(string: [*c]const JSChar, numChars: size_t) JSStringRef;
+

src/javascript/jsc/javascript.zig

@@ -0,0 +1,534 @@
+const js = @import("./JavaScriptCore.zig");
+const std = @import("std");
+usingnamespace @import("../../global.zig");
+const Fs = @import("../../fs.zig");
+const resolver = @import("../../resolver/resolver.zig");
+const ast = @import("../../ast/base.zig");
+const NodeModuleBundle = @import("../../node_module_bundle.zig").NodeModuleBundle;
+const WTFString = @import("../../wtf_string_mutable.zig").WTFStringMutable;
+const logger = @import("../../logger.zig");
+pub const ExportJavaScript = union(Tag) {
+    Module: *Module,
+    String: *String,
+    GlobalObject: *GlobalObject,
+
+    pub const Tag = enum {
+        Module,
+        String,
+        GlobalObject,
+    };
+};
+
+pub const ResolveFunctionType = fn (ctx: anytype, source_dir: string, import_path: string, import_kind: ast.ImportKind) anyerror!resolver.Result;
+pub const TranspileFunctionType = fn (ctx: anytype, resolve_result: resolver.Result) anyerror![:0]const u8;
+
+const JSStringMapContext = struct {
+    pub fn hash(self: @This(), s: js.JSStringRef) u64 {
+        return hashString(s);
+    }
+    pub fn eql(self: @This(), a: js.JSStringRef, b: js.JSStringRef) bool {
+        return eqlString(a, b);
+    }
+};
+
+pub fn JSStringMap(comptime V: type) type {
+    return std.HashMap(js.JSStringRef, V, JSStringMapContext, 60);
+}
+
+// If you read JavascriptCore/API/JSVirtualMachine.mm - https://github.com/WebKit/WebKit/blob/acff93fb303baa670c055cb24c2bad08691a01a0/Source/JavaScriptCore/API/JSVirtualMachine.mm#L101
+// We can see that it's sort of like std.mem.Allocator but for JSGlobalContextRef, to support Automatic Reference Counting
+// Its unavailable on Linux
+pub const VirtualMachine = struct {
+    const RequireCacheType = std.AutoHashMap(u64, Module);
+    ctx: js.JSGlobalContextRef,
+    group: js.JSContextGroupRef,
+    allocator: *std.mem.Allocator,
+    transpile_ctx: *c_void = undefined,
+    transpile: *TranspileFunctionType = undefined,
+    require_cache: RequireCacheType,
+    resolve_: *ResolveFunctionType = undefined,
+    resolve_ctx: *c_void = undefined,
+    node_modules: ?*NodeModuleBundle = null,
+    node_modules_ref: js.JSObjectRef = null,
+    global: GlobalObject,
+
+    pub fn init(allocator: *std.mem.Allocator) !*VirtualMachine {
+        var group = js.JSContextGroupCreate();
+        var ctx = js.JSGlobalContextCreateInGroup(group, null);
+
+        Properties.init();
+        var vm = try allocator.create(VirtualMachine);
+        vm.* = .{
+            .allocator = allocator,
+            .group = group,
+            .ctx = ctx,
+            .require_cache = RequireCacheType.init(allocator),
+            .global = undefined,
+        };
+        vm.global = GlobalObject{ .vm = undefined };
+        return vm;
+    }
+
+    pub fn setupGlobals(this: *VirtualMachine) void {}
+
+    pub fn resolve(
+        this: *VirtualMachine,
+        from: *const Module,
+        to: string,
+    ) !js.JSValueRef {
+        return (try this.resolve_(this.resolve_ctx, from.path.dir, to, .require)) orelse return error.ModuleNotFound;
+    }
+    threadlocal var require_buf: [std.fs.MAX_PATH_BYTES]u8 = undefined;
+
+    // Assume bundle is already transpiled, so we skip transpiling in here.
+    pub fn requireFromBundle(this: *VirtualMachine, import_path: string) !js.JSValueRef {}
+
+    pub fn require(
+        this: *VirtualMachine,
+        module: *const Module,
+        path_value: js.JSValueRef,
+    ) !js.JSValueRef {
+        var import_path = To.Zig.str(path_value, &require_buf);
+        var resolve_result = try this.resolve(module, import_path);
+    }
+
+    threadlocal var eval_buf: WTFString = undefined;
+    threadlocal var eval_buf_loaded: bool = false;
+
+    pub fn evalUtf8(
+        this: *VirtualMachine,
+        path_text: string,
+        contents: string,
+    ) !js.JSValueRef {
+        if (!eval_buf_loaded) {
+            eval_buf = try WTFString.init(this.allocator, contents.len + path.text.len + 2);
+        } else {
+            eval_buf.reset();
+            try eval_buf.growIfNeeded(contents.len + path.text.len + 2);
+        }
+
+        try eval_buf.append(contents);
+        eval_buf.list.append(eval_buf.allocator, 0);
+        var script_len = eval_buf.list.items.len;
+        if (path_text.len > 0) {
+            try eval_buf.append(path_text);
+            eval_buf.list.append(eval_buf.allocator, 0);
+        }
+
+        var buf = eval_buf.toOwnedSliceLeaky();
+        var script = js.JSStringCreateWithCharactersNoCopy(buf[0..script_len].ptr, script_len - 1);
+        var sourceURL: js.JSStringRef = null;
+
+        if (path_text.len > 0) {
+            sourceURL = js.JSStringCreateWithCharactersNoCopy(
+                buf[script_len + 1 ..].ptr,
+                buf[script_len + 1 ..].len - 1,
+            );
+        }
+
+        return js.JSEvaluateScript(
+            this.ctx,
+            script,
+            js.JSValueMakeUndefined(this.ctx),
+            sourceURL,
+            0,
+            null,
+        );
+    }
+};
+
+pub const BundleLoader = struct {
+    bundle: *const NodeModuleBundle,
+    allocator: *std.mem.Allocator,
+    vm: *VirtualMachine,
+    loaded: bool = false,
+    ref: js.JSObjectRef = null,
+
+    pub fn init(bundle: *const NodeModuleBundle, allocator: *std.mem.Allocator, vm: *VirtualMachine) BundleLoader {
+        return BundleLoader{
+            .bundle = bundle,
+            .allocator = allocator,
+            .vm = vm,
+        };
+    }
+
+    pub fn loadBundle(this: *BundleLoader) !void {}
+};
+
+pub const To = struct {
+    pub const JS = struct {
+        pub inline fn str(ref: anytype, val: anytype) js.JSStringRef {
+            return js.JSStringCreateWithUTF8CString(val[0.. :0]);
+        }
+
+        pub fn functionWithCallback(
+            comptime ZigContextType: type,
+            zig: *ZigContextType,
+            name: js.JSStringRef,
+            ctx: js.JSContextRef,
+            comptime callback: fn (
+                obj: *ZigContextType,
+                ctx: js.JSContextRef,
+                function: js.JSObjectRef,
+                thisObject: js.JSObjectRef,
+                arguments: []js.JSValueRef,
+                exception: [*c]js.JSValueRef,
+            ) js.JSValueRef,
+        ) js.JSObjectRef {
+            var function = js.JSObjectMakeFunctionWithCallback(ctx, name, Callback(ZigContextType, callback));
+            js.JSObjectSetPrivate(function, @ptrCast(*c_void, zig));
+            return function;
+        }
+
+        pub fn Callback(
+            comptime ZigContextType: type,
+            comptime ctxfn: fn (
+                obj: *ZigContextType,
+                ctx: js.JSContextRef,
+                function: js.JSObjectRef,
+                thisObject: js.JSObjectRef,
+                arguments: []js.JSValueRef,
+                exception: [*c]js.JSValueRef,
+            ) js.JSValueRef,
+        ) type {
+            return struct {
+                pub fn run(
+                    ctx: js.JSContextRef,
+                    function: js.JSObjectRef,
+                    thisObject: js.JSObjectRef,
+                    argumentCount: usize,
+                    arguments: [*c]const js.JSValueRef,
+                    exception: [*c]js.JSValueRef,
+                ) callconv(.C) js.JSValueRef {
+                    var object_ptr = js.JSObjectGetPrivate(function) orelse {
+                        return js.JSValueMakeUndefined(ctx);
+                    };
+
+                    return ctxfn(
+                        @intToPtr(ZigContextType, object_ptr),
+                        ctx,
+                        function,
+                        thisObject,
+                        arguments[0..argumentCount],
+                        exception,
+                    );
+                }
+            };
+        }
+    };
+
+    pub const Ref = struct {
+        pub inline fn str(ref: anytype) js.JSStringRef {
+            return @as(js.JSStringRef, ref);
+        }
+    };
+
+    pub const Zig = struct {
+        pub inline fn str(ref: anytype, buf: anytype) string {
+            return buf[0..js.JSStringGetUTF8CString(Ref.str(ref), buf.ptr, buf.len)];
+        }
+    };
+};
+
+pub const Properties = struct {
+    pub const UTF8 = struct {
+        pub const module = "module";
+        pub const globalThis = "globalThis";
+        pub const exports = "exports";
+        pub const log = "log";
+        pub const debug = "debug";
+        pub const info = "info";
+        pub const error_ = "error";
+        pub const warn = "warn";
+        pub const console = "console";
+        pub const require = "require";
+        pub const description = "description";
+    };
+
+    pub const UTF16 = struct {
+        pub const module = std.unicode.utf8ToUtf16LeStringLiteral("module");
+        pub const globalThis = std.unicode.utf8ToUtf16LeStringLiteral("globalThis");
+        pub const exports = std.unicode.utf8ToUtf16LeStringLiteral("exports");
+        pub const log = std.unicode.utf8ToUtf16LeStringLiteral("log");
+        pub const debug = std.unicode.utf8ToUtf16LeStringLiteral("debug");
+        pub const info = std.unicode.utf8ToUtf16LeStringLiteral("info");
+        pub const error_ = std.unicode.utf8ToUtf16LeStringLiteral("error");
+        pub const warn = std.unicode.utf8ToUtf16LeStringLiteral("warn");
+        pub const console = std.unicode.utf8ToUtf16LeStringLiteral("console");
+        pub const require = std.unicode.utf8ToUtf16LeStringLiteral("require");
+        pub const description = std.unicode.utf8ToUtf16LeStringLiteral("description");
+    };
+
+    pub const Refs = struct {
+        pub var module: js.JSStringRef = undefined;
+        pub var globalThis: js.JSStringRef = undefined;
+        pub var exports: js.JSStringRef = undefined;
+        pub var log: js.JSStringRef = undefined;
+        pub var debug: js.JSStringRef = undefined;
+        pub var info: js.JSStringRef = undefined;
+        pub var error_: js.JSStringRef = undefined;
+        pub var warn: js.JSStringRef = undefined;
+        pub var console: js.JSStringRef = undefined;
+        pub var require: js.JSStringRef = undefined;
+        pub var description: js.JSStringRef = undefined;
+    };
+
+    pub fn init() void {
+        inline for (std.meta.fieldNames(UTF8)) |name| {
+            @field(Refs, name) = js.JSStringCreateWithCharactersNoCopy(
+                &@field(StringStore.UTF16, name),
+                @field(StringStore.UTF16, name).len,
+            );
+        }
+    }
+};
+
+pub const Object = struct {
+    ref: js.jsObjectRef,
+};
+
+pub const String = struct {
+    ref: js.JSStringRef,
+    len: usize,
+
+    pub fn chars(this: *const String) []js.JSChar {
+        return js.JSStringGetCharactersPtr(this.ref)[0..js.JSStringGetLength(this.ref)];
+    }
+
+    pub fn eql(this: *const String, str: [*c]const u8) bool {
+        return str.len == this.len and js.JSStringIsEqualToUTF8CString(this, str);
+    }
+};
+
+pub const Module = struct {
+    path: Fs.PathName,
+
+    require: RequireObject,
+    hash: u64,
+    ref: js.JSObjectRef,
+
+    pub const RequireObject = struct {};
+
+    pub fn require(
+        this: *Module,
+        arguments: [*c]const js.JSValueRef,
+        arguments_len: usize,
+        exception: [*c]JSValueRef,
+    ) js.JSValueRef {}
+};
+
+pub const GlobalObject = struct {
+    ref: js.JSObjectRef = undefined,
+    vm: *VirtualMachine,
+    console: js.JSClassRef = undefined,
+    console_definition: js.JSClassDefinition = undefined,
+
+    pub const ConsoleClass = NewSingletonClass(
+        GlobalObject,
+        "Console",
+        .{
+            .@"log" = stdout,
+            .@"info" = stdout,
+            .@"debug" = stdout,
+            .@"verbose" = stdout,
+
+            .@"error" = stderr,
+            .@"warn" = stderr,
+        },
+        // people sometimes modify console.log, let them.
+        false,
+    );
+
+    pub fn load(global: *GlobalObject) !void {
+        global.console_definition = ConsoleClass.define(global, global.vm.ctx);
+        global.console = js.JSClassCreate(&global.console_definition);
+    }
+
+    fn valuePrinter(comptime ValueType: js.JSType, ctx: js.JSContextRef, arg: js.JSValueRef, writer: anytype) !void {
+        switch (ValueType) {
+            .kJSTypeUndefined => {
+                try writer.writeAll("undefined");
+            },
+            .kJSTypeNull => {
+                try writer.writeAll("null");
+            },
+            .kJSTypeBoolean => {
+                if (js.JSValueToBoolean(ctx, arg)) {
+                    try writer.writeAll("true");
+                } else {
+                    try writer.writeAll("false");
+                }
+            },
+            .kJSTypeNumber => {
+                try writer.print("{d}", js.JSValueToNumber(ctx, arg, null));
+            },
+            .kJSTypeString => {
+                var str = String{ .ref = @as(js.JSStringRef, arg) };
+                var chars = str.chars();
+                switch (chars.len) {
+                    0 => {
+                        try writer.writeAll("\"\"");
+                    },
+                    else => {
+                        for (chars) |c, i| {
+                            switch (c) {
+                                0...127 => {
+                                    // Since we're writing character by character
+                                    // it will be really slow if we check for an error every time
+                                    _ = writer.write(@intCast(u8, c)) catch 0;
+                                },
+                                // TODO:
+                                else => {},
+                            }
+                        }
+                    },
+                }
+            },
+            .kJSTypeObject => {
+                // TODO:
+                try writer.writeAll("[Object object]");
+            },
+            .kJSTypeSymbol => {
+                var description = js.JSObjectGetPropertyForKey(ctx, arg, Properties.Refs.description, null);
+                return switch (js.JSValueGetType(ctx, description)) {
+                    .kJSTypeString => try valuePrinter(.kJSTypeString, ctx, description, writer),
+                    else => try valuePrinter(.kJSTypeUndefined, ctx, description, writer),
+                };
+            },
+            else => {},
+        }
+    }
+
+    fn output(
+        writer: anytype,
+        ctx: js.JSContextRef,
+        arguments: []js.JSValueRef,
+    ) !void {
+        defer Output.flush();
+        // console.log();
+        if (arguments.len == 0) {
+            return js.JSValueMakeUndefined(ctx);
+        }
+
+        const last = arguments.len - 1;
+
+        for (arguments) |arg, i| {
+            switch (js.JSValueGetType(ctx, arg)) {
+                .kJSTypeUndefined => {
+                    try valuePrinter(.kJSTypeUndefined, ctx, arg, writer);
+                    if (i != last) {
+                        try writer.writeAll(" ");
+                    }
+                },
+                .kJSTypeNull => {
+                    try valuePrinter(.kJSTypeNull, ctx, arg, writer);
+                    if (i != last) {
+                        try writer.writeAll(" ");
+                    }
+                },
+                .kJSTypeBoolean => {
+                    try valuePrinter(.kJSTypeBoolean, ctx, arg, writer);
+                    if (i != last) {
+                        try writer.writeAll(" ");
+                    }
+                },
+                .kJSTypeNumber => {
+                    try valuePrinter(.kJSTypeNumber, ctx, arg, writer);
+                    if (i != last) {
+                        try writer.writeAll(" ");
+                    }
+                },
+                .kJSTypeString => {
+                    try valuePrinter(.kJSTypeString, ctx, arg, writer);
+                    if (i != last) {
+                        try writer.writeAll(" ");
+                    }
+                },
+                .kJSTypeObject => {
+                    try valuePrinter(.kJSTypeObject, ctx, arg, writer);
+                    if (i != last) {
+                        try writer.writeAll(" ");
+                    }
+                },
+                .kJSTypeSymbol => {
+                    try valuePrinter(.kJSTypeSymbol, ctx, arg, writer);
+                    if (i != last) {
+                        try writer.writeAll(" ");
+                    }
+                },
+                else => {},
+            }
+        }
+
+        return js.JSValueMakeUndefined(ctx);
+    }
+
+    pub fn stdout(
+        obj: *GlobalObject,
+        ctx: js.JSContextRef,
+        function: js.JSObjectRef,
+        thisObject: js.JSObjectRef,
+        arguments: []js.JSValueRef,
+    ) js.JSValueRef {
+        return try output(Output.writer(), ctx, arguments);
+    }
+
+    pub fn stderr(
+        obj: *GlobalObject,
+        ctx: js.JSContextRef,
+        function: js.JSObjectRef,
+        thisObject: js.JSObjectRef,
+        arguments: []js.JSValueRef,
+    ) js.JSValueRef {
+        return try output(Output.errorWriter(), ctx, arguments);
+        // js.JSObjectMakeFunctionWithCallback(ctx: JSContextRef, name: JSStringRef, callAsFunction: JSObjectCallAsFunctionCallback)
+    }
+};
+
+pub fn NewSingletonClass(
+    comptime ZigType: type,
+    comptime name: string,
+    comptime functions: anytype,
+    comptime read_only: bool,
+) type {
+    return struct {
+        const ClassDefinitionCreator = @This();
+        const function_names = std.meta.fieldNames(functions);
+        const function_name_literals: [function_names.len][]js.JSChar = brk: {
+            var names = std.mem.zeroes([function_names.len][]js.JSChar);
+
+            for (function_names) |field, i| {
+                names[i] = std.unicode.utf8ToUtf16LeStringLiteral(field);
+            }
+            break :brk names;
+        };
+        var function_name_refs: [function_names.len]js.JSStringRef = undefined;
+
+        const class_name_literal = std.unicode.utf8ToUtf16LeStringLiteral(name);
+        var static_functions: [function_name_refs.len + 1:0]js.JSStaticFunction = undefined;
+
+        pub fn define(zig: *ZigType, ctx: js.JSContextRef) !js.JSClassDefinition {
+            var def = std.mem.zeroes(js.JSClassDefinition);
+
+            inline for (function_name_literals) |function_name, i| {
+                function_name_refs[i] = js.JSStringCreateWithCharactersNoCopy(&function_name, function_name.len);
+                static_functions[i] = js.JSStaticFunction{
+                    .name = (function_names[i][0.. :0]).ptr,
+                    .callAsFunction = To.JS.functionWithCallback(
+                        ZigType,
+                        zig,
+                        function_name_refs[i],
+                        ctx,
+                        @field(functions, function_names[i]),
+                    ),
+                    .attributes = comptime if (read_only) js.JSPropertyAttributes.kJSPropertyAttributeReadOnly else js.JSPropertyAttributes.kJSPropertyAttributeNone,
+                };
+            }
+            static_functions[function_name_literals.len] = std.mem.zeroes(js.JSStaticFunction);
+            def.staticFunctions = static_functions[0.. :0].ptr;
+            def.className = name[0.. :0].ptr;
+
+            return def;
+        }
+    };
+}