#include "VM.h"

#include <climits>

#include <cmath>

#include <cstdint>

#include <cstring>

#include <memory>

#include <regex>

#include <string>

#include <unordered_map>

#include <unordered_set>

#include <vector>

#include "js_native_api.h"

#include "native_api_util.h"

#if defined(TARGET_ENGINE_V8)

#include "v8-api.h"

#elif defined(TARGET_ENGINE_QUICKJS)

#include "quickjs.h"

#include "quicks-runtime.h"

#endif

namespace nativescript {

namespace {

constexpr char kContextSymbolName[] = "nativescript.vm.context";

constexpr char kDefaultFilename[] = "vm.js";

constexpr char kDefaultModuleIdentifier[] = "vm:module";

bool IsNullOrUndefined(napi_env env, napi_value value) {

if (value == nullptr) {

return true;

}

napi_valuetype type;

if (napi_typeof(env, value, &type) != napi_ok) {

return false;

}

return type == napi_null || type == napi_undefined;

}

bool IsObjectLike(napi_env env, napi_value value) {

if (value == nullptr) {

return false;

}

napi_valuetype type;

if (napi_typeof(env, value, &type) != napi_ok) {

return false;

}

return type == napi_object || type == napi_function;

}

bool CoerceToString(napi_env env, napi_value value, std::string& out) {

napi_value coerced;

if (napi_coerce_to_string(env, value, &coerced) != napi_ok) {

return false;

}

size_t length = 0;

if (napi_get_value_string_utf8(env, coerced, nullptr, 0, &length) !=

napi_ok) {

return false;

}

std::vector<char> buffer(length + 1);

if (napi_get_value_string_utf8(env, coerced, buffer.data(), buffer.size(),

nullptr) != napi_ok) {

return false;

}

out.assign(buffer.data(), length);

return true;

}

bool ReadOptionalStringProperty(napi_env env, napi_value object,

const char* property, std::string& out) {

if (IsNullOrUndefined(env, object)) {

return false;

}

bool hasProperty = false;

if (napi_has_named_property(env, object, property, &hasProperty) != napi_ok ||

!hasProperty) {

return false;

}

napi_value value;

if (napi_get_named_property(env, object, property, &value) != napi_ok) {

return false;

}

return CoerceToString(env, value, out);

}

bool ReadOptionalProperty(napi_env env, napi_value object, const char* property,

napi_value* out) {

if (IsNullOrUndefined(env, object)) {

return false;

}

bool hasProperty = false;

if (napi_has_named_property(env, object, property, &hasProperty) != napi_ok ||

!hasProperty) {

return false;

}

return napi_get_named_property(env, object, property, out) == napi_ok;

}

std::string ReadIdentifierOption(

napi_env env, napi_value options,

const std::string& fallback = kDefaultModuleIdentifier) {

std::string identifier;

if (ReadOptionalStringProperty(env, options, "identifier", identifier) &&

!identifier.empty()) {

return identifier;

}

if (ReadOptionalStringProperty(env, options, "filename", identifier) &&

!identifier.empty()) {

return identifier;

}

if (!identifier.empty()) {

return identifier;

}

return fallback;

}

napi_value CreateUint8ArrayCopy(napi_env env, const uint8_t* data,

size_t length) {

void* bufferData = nullptr;

napi_value arrayBuffer;

if (napi_create_arraybuffer(env, length, &bufferData, &arrayBuffer) !=

napi_ok) {

return nullptr;

}

if (length > 0 && data != nullptr) {

memcpy(bufferData, data, length);

}

napi_value typedArray;

if (napi_create_typedarray(env, napi_uint8_array, length, arrayBuffer, 0,

&typedArray) != napi_ok) {

return nullptr;

}

return typedArray;

}

napi_value CreateStringArray(napi_env env,

const std::vector<std::string>& values) {

napi_value array;

if (napi_create_array_with_length(env, values.size(), &array) != napi_ok) {

return nullptr;

}

for (size_t index = 0; index < values.size(); ++index) {

napi_value entry;

if (napi_create_string_utf8(env, values[index].c_str(),

values[index].size(), &entry) != napi_ok ||

napi_set_element(env, array, index, entry) != napi_ok) {

return nullptr;

}

}

return array;

}

bool GetStringArray(napi_env env, napi_value value,

std::vector<std::string>& out) {

bool isArray = false;

if (napi_is_array(env, value, &isArray) != napi_ok || !isArray) {

return false;

}

uint32_t length = 0;

if (napi_get_array_length(env, value, &length) != napi_ok) {

return false;

}

out.clear();

out.reserve(length);

for (uint32_t index = 0; index < length; ++index) {

napi_value element;

std::string text;

if (napi_get_element(env, value, index, &element) != napi_ok ||

!CoerceToString(env, element, text)) {

return false;

}

out.push_back(text);

}

return true;

}

bool CreatePromiseSettledWithUndefined(napi_env env, bool rejected,

napi_value reasonOrValue,

napi_value* result) {

napi_deferred deferred;

if (napi_create_promise(env, &deferred, result) != napi_ok) {

return false;

}

napi_value undefined;

napi_get_undefined(env, &undefined);

if (rejected) {

return napi_reject_deferred(

env, deferred,

reasonOrValue != nullptr ? reasonOrValue : undefined) == napi_ok;

}

return napi_resolve_deferred(

env, deferred,

reasonOrValue != nullptr ? reasonOrValue : undefined) == napi_ok;

}

std::vector<std::string> ExtractModuleDependencySpecifiers(

const std::string& source) {

static const std::regex kImportFromPattern(

R"((?:^|[\r\n])\s*import\s+[^;]*?\s+from\s+['"]([^'"]+)['"])",

std::regex::ECMAScript);

static const std::regex kImportOnlyPattern(

R"((?:^|[\r\n])\s*import\s+['"]([^'"]+)['"])", std::regex::ECMAScript);

std::vector<std::string> specifiers;

std::unordered_set<std::string> seen;

for (std::sregex_iterator

it(source.begin(), source.end(), kImportFromPattern),

end;

it != end; ++it) {

const std::string specifier = (*it)[1].str();

if (seen.insert(specifier).second) {

specifiers.push_back(specifier);

}

}

for (std::sregex_iterator

it(source.begin(), source.end(), kImportOnlyPattern),

end;

it != end; ++it) {

const std::string specifier = (*it)[1].str();

if (seen.insert(specifier).second) {

specifiers.push_back(specifier);

}

}

return specifiers;

}

std::string ReadFilenameOption(napi_env env, napi_value options,

const std::string& fallback = kDefaultFilename) {

if (IsNullOrUndefined(env, options)) {

return fallback;

}

napi_valuetype type;

if (napi_typeof(env, options, &type) != napi_ok) {

return fallback;

}

if (type == napi_string) {

std::string filename;

if (CoerceToString(env, options, filename) && !filename.empty()) {

return filename;

}

return fallback;

}

if (type != napi_object) {

return fallback;

}

bool hasFilename = false;

if (napi_has_named_property(env, options, "filename", &hasFilename) !=

napi_ok ||

!hasFilename) {

return fallback;

}

napi_value filenameValue;

if (napi_get_named_property(env, options, "filename", &filenameValue) !=

napi_ok) {

return fallback;

}

std::string filename;

if (CoerceToString(env, filenameValue, filename) && !filename.empty()) {

return filename;

}

return fallback;

}

napi_value GetContextSymbol(napi_env env) {

napi_value global;

napi_value symbolCtor;

napi_value symbolFor;

napi_value description;

napi_value symbol;

napi_get_global(env, &global);

napi_get_named_property(env, global, "Symbol", &symbolCtor);

napi_get_named_property(env, symbolCtor, "for", &symbolFor);

napi_create_string_utf8(env, kContextSymbolName, NAPI_AUTO_LENGTH,

&description);

napi_call_function(env, symbolCtor, symbolFor, 1, &description, &symbol);

return symbol;

}

struct ContextState {

#if defined(TARGET_ENGINE_V8)

v8::Global<v8::Context> context;

#elif defined(TARGET_ENGINE_QUICKJS)

JSRuntime* runtime = nullptr;

JSContext* context = nullptr;

#endif

std::unordered_set<std::string> baselineKeys;

~ContextState() {

#if defined(TARGET_ENGINE_V8)

context.Reset();

#elif defined(TARGET_ENGINE_QUICKJS)

if (context != nullptr) {

JS_FreeContext(context);

context = nullptr;

}

#endif

}

};

struct ScriptState {

std::string source;

std::string filename;

};

enum class ModuleKind {

kSourceText,

kSynthetic,

};

struct ModuleState {

napi_env env = nullptr;

ModuleKind kind = ModuleKind::kSourceText;

std::string identifier;

std::vector<std::string> dependencySpecifiers;

std::vector<std::string> exportNames;

std::vector<ModuleState*> linkedModules;

napi_ref contextRef = nullptr;

ContextState* contextState = nullptr;

napi_ref errorRef = nullptr;

#if defined(TARGET_ENGINE_V8)

v8::Global<v8::Module> module;

#elif defined(TARGET_ENGINE_QUICKJS)

JSRuntime* runtime = nullptr;

JSContext* context = nullptr;

JSValue moduleValue = JS_UNDEFINED;

std::unordered_map<std::string, JSValue> syntheticExports;

bool linked = false;

bool evaluating = false;

bool evaluated = false;

bool errored = false;

std::string errorMessage;

#endif

};

#if defined(TARGET_ENGINE_V8)

std::unordered_map<int, ModuleState*>& GetV8ModuleRegistry();

#elif defined(TARGET_ENGINE_QUICKJS)

struct QuickJSModuleRegistry {

bool installed = false;

std::unordered_map<std::string, ModuleState*> modulesById;

std::unordered_map<JSModuleDef*, ModuleState*> modulesByDef;

std::unordered_map<std::string, std::string> resolutions;

};

std::unordered_map<JSRuntime*, QuickJSModuleRegistry>&

GetQuickJSModuleRegistries();

std::string MakeQuickJSResolutionKey(const std::string& base,

const std::string& specifier);

QuickJSModuleRegistry& EnsureQuickJSModuleRegistry(JSRuntime* runtime);

std::string GetQuickJSModuleStatusString(ModuleState* state);

bool EnsureQuickJSImportMeta(ModuleState* state);

bool EnsureQuickJSLinked(napi_env env, ModuleState* state);

bool CacheQuickJSError(napi_env env, ModuleState* state, JSValue exception);

bool CreateQuickJSSourceTextModule(napi_env env, const std::string& sourceText,

napi_value options, napi_value* result);

bool CreateQuickJSSyntheticModule(napi_env env,

const std::vector<std::string>& exportNames,

napi_value options, napi_value* result);

void CleanupQuickJSModuleState(ModuleState* state);

bool ApplyQuickJSSyntheticExports(ModuleState* state);

#endif

void FinalizeContextState(napi_env env, void* data, void* /*hint*/) {

delete static_cast<ContextState*>(data);

}

void FinalizeScriptState(napi_env env, void* data, void* /*hint*/) {

delete static_cast<ScriptState*>(data);

}

void FinalizeModuleState(napi_env env, void* data, void* /*hint*/) {

ModuleState* state = static_cast<ModuleState*>(data);

if (state == nullptr) {

return;

}

if (state->contextRef != nullptr) {

napi_delete_reference(env, state->contextRef);

state->contextRef = nullptr;

}

if (state->errorRef != nullptr) {

napi_delete_reference(env, state->errorRef);

state->errorRef = nullptr;

}

#if defined(TARGET_ENGINE_V8)

auto& registry = GetV8ModuleRegistry();

for (auto it = registry.begin(); it != registry.end();) {

if (it->second == state) {

it = registry.erase(it);

} else {

++it;

}

}

state->module.Reset();

#elif defined(TARGET_ENGINE_QUICKJS)

CleanupQuickJSModuleState(state);

#endif

delete state;

}

bool GetContextState(napi_env env, napi_value sandbox, ContextState** out) {

*out = nullptr;

if (!IsObjectLike(env, sandbox)) {

return false;

}

napi_value symbol = GetContextSymbol(env);

bool hasState = false;

if (napi_has_property(env, sandbox, symbol, &hasState) != napi_ok ||

!hasState) {

return false;

}

napi_value stateValue;

if (napi_get_property(env, sandbox, symbol, &stateValue) != napi_ok) {

return false;

}

void* rawState = nullptr;

if (napi_get_value_external(env, stateValue, &rawState) != napi_ok ||

rawState == nullptr) {

return false;

}

*out = static_cast<ContextState*>(rawState);

return true;

}

bool RequireContextState(napi_env env, napi_value sandbox, ContextState** out) {

if (GetContextState(env, sandbox, out)) {

return true;

}

napi_throw_type_error(env, nullptr,

"The \"contextifiedObject\" argument must be a vm "

"context created by vm.createContext()");

return false;

}

bool ReadModuleContextOption(napi_env env, napi_value options,

ContextState** outState,

napi_value* outContextObject) {

*outState = nullptr;

if (outContextObject != nullptr) {

*outContextObject = nullptr;

}

napi_value contextValue;

if (!ReadOptionalProperty(env, options, "context", &contextValue) ||

IsNullOrUndefined(env, contextValue)) {

return true;

}

if (!RequireContextState(env, contextValue, outState)) {

return false;

}

if (outContextObject != nullptr) {

*outContextObject = contextValue;

}

return true;

}

bool CreateModuleHandle(napi_env env, ModuleState* state, napi_value* result) {

return napi_create_external(env, state, FinalizeModuleState, nullptr,

result) == napi_ok;

}

bool GetModuleState(napi_env env, napi_value value, ModuleState** out) {

*out = nullptr;

void* raw = nullptr;

if (napi_get_value_external(env, value, &raw) != napi_ok || raw == nullptr) {

napi_throw_type_error(env, nullptr, "Invalid vm.Module handle");

return false;

}

*out = static_cast<ModuleState*>(raw);

return true;

}

bool SetModuleError(napi_env env, ModuleState* state, napi_value error) {

if (state->errorRef != nullptr) {

napi_delete_reference(env, state->errorRef);

state->errorRef = nullptr;

}

if (IsNullOrUndefined(env, error)) {

return true;

}

return napi_create_reference(env, error, 1, &state->errorRef) == napi_ok;

}

napi_value GetStoredModuleError(napi_env env, ModuleState* state) {

if (state->errorRef == nullptr) {

napi_value undefined;

napi_get_undefined(env, &undefined);

return undefined;

}

napi_value error;

if (napi_get_reference_value(env, state->errorRef, &error) != napi_ok) {

return nullptr;

}

return error;

}

napi_value GetStoredModuleContext(napi_env env, ModuleState* state) {

if (state->contextRef == nullptr) {

napi_value undefined;

napi_get_undefined(env, &undefined);

return undefined;

}

napi_value context;

if (napi_get_reference_value(env, state->contextRef, &context) != napi_ok) {

return nullptr;

}

return context;

}

#if defined(TARGET_ENGINE_V8)

std::vector<std::string> CollectV8OwnStringKeys(v8::Isolate* isolate,

v8::Local<v8::Context> context,

v8::Local<v8::Object> object) {

std::vector<std::string> result;

v8::Local<v8::Array> names;

if (!object->GetOwnPropertyNames(context).ToLocal(&names)) {

return result;

}

const uint32_t length = names->Length();

result.reserve(length);

for (uint32_t index = 0; index < length; ++index) {

v8::Local<v8::Value> key;

if (!names->Get(context, index).ToLocal(&key) || !key->IsString()) {

continue;

}

v8::String::Utf8Value utf8(isolate, key);

if (*utf8 == nullptr) {

continue;

}

result.emplace_back(*utf8, utf8.length());

}

return result;

}

std::unordered_set<std::string> ToKeySet(const std::vector<std::string>& keys) {

return std::unordered_set<std::string>(keys.begin(), keys.end());

}

#if defined(TARGET_ENGINE_QUICKJS)

struct QuickJSModuleRegistry {

bool installed = false;

std::unordered_map<std::string, ModuleState*> modulesById;

std::unordered_map<std::string, std::string> resolutions;

};

std::unordered_map<JSRuntime*, QuickJSModuleRegistry>&

GetQuickJSModuleRegistries() {

static std::unordered_map<JSRuntime*, QuickJSModuleRegistry> registries;

return registries;

}

std::string MakeQuickJSResolutionKey(const std::string& base,

const std::string& specifier) {

return base + "\n" + specifier;

}

char* NormalizeQuickJSVmModule(JSContext* ctx, const char* base_name,

const char* name, void* opaque) {

QuickJSModuleRegistry* registry = static_cast<QuickJSModuleRegistry*>(opaque);

if (registry == nullptr) {

return js_strdup(ctx, name);

}

const std::string base = base_name != nullptr ? base_name : "";

const auto it =

registry->resolutions.find(MakeQuickJSResolutionKey(base, name));

if (it != registry->resolutions.end()) {

return js_strdup(ctx, it->second.c_str());

}

return js_strdup(ctx, name);

}

JSModuleDef* LoadQuickJSVmModule(JSContext* /*ctx*/, const char* module_name,

void* opaque) {

QuickJSModuleRegistry* registry = static_cast<QuickJSModuleRegistry*>(opaque);

if (registry == nullptr) {

return nullptr;

}

const auto it = registry->modulesById.find(module_name);

if (it == registry->modulesById.end() || it->second == nullptr) {

return nullptr;

}

return static_cast<JSModuleDef*>(JS_VALUE_GET_PTR(it->second->moduleValue));

}

QuickJSModuleRegistry& EnsureQuickJSModuleRegistry(JSRuntime* runtime) {

auto& registries = GetQuickJSModuleRegistries();

QuickJSModuleRegistry& registry = registries[runtime];

if (!registry.installed) {

JS_SetModuleLoaderFunc(runtime, &NormalizeQuickJSVmModule,

&LoadQuickJSVmModule, &registry);

registry.installed = true;

}

return registry;

}

std::string GetQuickJSModuleStatusString(ModuleState* state) {

if (state->errored) {

return "errored";

}

if (state->evaluating) {

return "evaluating";

}

if (state->evaluated) {

return "evaluated";

}

if (state->linked) {

return "linked";

}

return "unlinked";

}

bool EnsureQuickJSImportMeta(ModuleState* state) {

JSModuleDef* module =

static_cast<JSModuleDef*>(JS_VALUE_GET_PTR(state->moduleValue));

JSValue meta = JS_GetImportMeta(state->context, module);

if (JS_IsException(meta)) {

return false;

}

if (JS_DefinePropertyValueStr(

state->context, meta, "url",

JS_NewString(state->context, state->identifier.c_str()),

JS_PROP_C_W_E) < 0 ||

JS_DefinePropertyValueStr(state->context, meta, "main", JS_FALSE,

JS_PROP_C_W_E) < 0) {

JS_FreeValue(state->context, meta);

return false;

}

JS_FreeValue(state->context, meta);

return true;

}

bool EnsureQuickJSLinked(napi_env env, ModuleState* state) {

if (state->linked) {

return true;

}

if (JS_ResolveModule(state->context, state->moduleValue) < 0) {

state->errored = true;

state->errorMessage = GetQuickJSExceptionMessage(

state->context, JS_GetException(state->context));

napi_throw_error(env, nullptr, state->errorMessage.c_str());

return false;

}

state->linked = true;

return true;

}

bool CacheQuickJSError(napi_env env, ModuleState* state, JSValue exception) {

JSContext* mainContext = qjs_get_context(env);

JSValue cloned = CloneQuickJSValue(state->context, mainContext, exception);

JS_FreeValue(state->context, exception);

if (JS_IsException(cloned)) {

state->errorMessage =

GetQuickJSExceptionMessage(mainContext, JS_GetException(mainContext));

napi_throw_error(env, nullptr, state->errorMessage.c_str());

return false;

}

napi_value error;

if (qjs_create_scoped_value(env, cloned, &error) != napi_ok ||

!SetModuleError(env, state, error)) {

return false;

}

return true;

}

bool CreateQuickJSSourceTextModule(napi_env env, const std::string& sourceText,

napi_value options, napi_value* result) {

ContextState* contextState = nullptr;

napi_value contextObject = nullptr;

if (!ReadModuleContextOption(env, options, &contextState, &contextObject)) {

return false;

}

JSContext* context =

contextState != nullptr ? contextState->context : qjs_get_context(env);

JSRuntime* runtime = JS_GetRuntime(context);

QuickJSModuleRegistry& registry = EnsureQuickJSModuleRegistry(runtime);

const std::string identifier = ReadIdentifierOption(env, options);

JSValue moduleValue = JS_Eval(

context, sourceText.c_str(), sourceText.size(), identifier.c_str(),

JS_EVAL_TYPE_MODULE | JS_EVAL_FLAG_COMPILE_ONLY |

JS_EVAL_FLAG_COMPILE_ONLY_NO_RESOLVE);

if (JS_IsException(moduleValue)) {

return ThrowLatestQuickJSException(env, context);

}

std::unique_ptr<ModuleState> state(new ModuleState());

state->env = env;

state->kind = ModuleKind::kSourceText;

state->identifier = identifier;

state->contextState = contextState;

state->runtime = runtime;

state->context = context;

state->moduleValue = moduleValue;

state->dependencySpecifiers = ExtractModuleDependencySpecifiers(sourceText);

if (contextObject != nullptr &&

napi_create_reference(env, contextObject, 1, &state->contextRef) !=

napi_ok) {

return false;

}

registry.modulesById[identifier] = state.get();

registry

.modulesByDef[static_cast<JSModuleDef*>(JS_VALUE_GET_PTR(moduleValue))] =

state.get();

if (!CreateModuleHandle(env, state.get(), result)) {

return false;

}

state.release();

return true;

}

bool ApplyQuickJSSyntheticExports(ModuleState* state) {

JSModuleDef* moduleDef =

static_cast<JSModuleDef*>(JS_VALUE_GET_PTR(state->moduleValue));

for (const auto& exportName : state->exportNames) {

JSValue exportValue = JS_UNDEFINED;

auto valueIt = state->syntheticExports.find(exportName);

if (valueIt != state->syntheticExports.end()) {

exportValue = JS_DupValue(state->context, valueIt->second);

}

if (JS_SetModuleExport(state->context, moduleDef, exportName.c_str(),

exportValue) < 0) {

return false;

}

}

return true;

}

int InitializeQuickJSSyntheticModule(JSContext* ctx, JSModuleDef* moduleDef) {

auto& registries = GetQuickJSModuleRegistries();

auto registryIt = registries.find(JS_GetRuntime(ctx));

if (registryIt == registries.end()) {

return -1;

}

auto stateIt = registryIt->second.modulesByDef.find(moduleDef);

if (stateIt == registryIt->second.modulesByDef.end() ||

stateIt->second == nullptr) {

return -1;

}

return ApplyQuickJSSyntheticExports(stateIt->second) ? 0 : -1;

}

bool CreateQuickJSSyntheticModule(napi_env env,

const std::vector<std::string>& exportNames,

napi_value options, napi_value* result) {

ContextState* contextState = nullptr;

napi_value contextObject = nullptr;

if (!ReadModuleContextOption(env, options, &contextState, &contextObject)) {

return false;

}

JSContext* context =

contextState != nullptr ? contextState->context : qjs_get_context(env);

JSRuntime* runtime = JS_GetRuntime(context);

QuickJSModuleRegistry& registry = EnsureQuickJSModuleRegistry(runtime);

const std::string identifier = ReadIdentifierOption(env, options);

JSModuleDef* moduleDef = JS_NewCModule(context, identifier.c_str(),

&InitializeQuickJSSyntheticModule);

if (moduleDef == nullptr) {

return ThrowLatestQuickJSException(env, context);

}

for (const auto& exportName : exportNames) {

if (JS_AddModuleExport(context, moduleDef, exportName.c_str()) < 0) {

return ThrowLatestQuickJSException(env, context);

}

}

std::unique_ptr<ModuleState> state(new ModuleState());

state->env = env;

state->kind = ModuleKind::kSynthetic;

state->identifier = identifier;

state->contextState = contextState;

state->runtime = runtime;

state->context = context;

state->exportNames = exportNames;

state->moduleValue = JS_DupValue(context, JS_MKPTR(JS_TAG_MODULE, moduleDef));

if (contextObject != nullptr &&

napi_create_reference(env, contextObject, 1, &state->contextRef) !=

napi_ok) {

return false;

}

registry.modulesById[identifier] = state.get();

registry.modulesByDef[moduleDef] = state.get();

if (!EnsureQuickJSLinked(env, state.get())) {

return false;

}

if (!CreateModuleHandle(env, state.get(), result)) {

return false;

}

state.release();

return true;

}

#endif

std::unordered_map<int, ModuleState*>& GetV8ModuleRegistry() {

static std::unordered_map<int, ModuleState*> registry;

return registry;

}

v8::Local<v8::Context> GetV8ModuleContext(napi_env env, ModuleState* state) {

return state->contextState != nullptr

? state->contextState->context.Get(env->isolate)

: env->context();

}

std::string GetV8ModuleStatusString(v8::Module::Status status) {

switch (status) {

case v8::Module::kUninstantiated:

return "unlinked";

case v8::Module::kInstantiating:

return "linking";

case v8::Module::kInstantiated:

return "linked";

case v8::Module::kEvaluating:

return "evaluating";

case v8::Module::kEvaluated:

return "evaluated";

case v8::Module::kErrored:

return "errored";

}

return "unlinked";

}

bool SetV8ModuleRegistryEntry(v8::Local<v8::Module> module,

ModuleState* state) {

GetV8ModuleRegistry()[module->GetIdentityHash()] = state;

return true;

}

v8::MaybeLocal<v8::Module> ResolveV8VmModuleByIndex(

v8::Local<v8::Context> context, size_t index,

v8::Local<v8::Module> referrer) {

auto& registry = GetV8ModuleRegistry();

auto it = registry.find(referrer->GetIdentityHash());

if (it == registry.end() || it->second == nullptr) {

return v8::MaybeLocal<v8::Module>();

}

ModuleState* referrerState = it->second;

if (index >= referrerState->linkedModules.size() ||

referrerState->linkedModules[index] == nullptr) {

return v8::MaybeLocal<v8::Module>();

}

v8::Isolate* isolate = v8::Isolate::GetCurrent();

return referrerState->linkedModules[index]->module.Get(isolate);

}

v8::MaybeLocal<v8::Value> EvaluateV8SyntheticModule(

v8::Local<v8::Context> context, v8::Local<v8::Module> /*module*/) {

v8::Isolate* isolate = v8::Isolate::GetCurrent();

v8::Local<v8::Promise::Resolver> resolver =

v8::Promise::Resolver::New(context).ToLocalChecked();

resolver->Resolve(context, v8::Undefined(isolate)).ToChecked();

return resolver->GetPromise();

}

bool ExtractV8DependencySpecifiers(v8::Isolate* isolate,

v8::Local<v8::Module> module,

std::vector<std::string>& out) {

out.clear();

v8::Local<v8::FixedArray> requests = module->GetModuleRequests();

const int length = requests->Length();

out.reserve(length);

for (int index = 0; index < length; ++index) {

v8::Local<v8::Data> entry =

requests->Get(isolate->GetCurrentContext(), index);

v8::Local<v8::String> specifier =

v8::ModuleRequest::Cast(*entry)->GetSpecifier();

v8::String::Utf8Value text(isolate, specifier);

if (*text == nullptr) {

return false;

}

out.emplace_back(*text, text.length());

}

return true;

}

std::vector<std::string> CollectV8ModuleExportNames(napi_env env,

ModuleState* state) {

v8::Isolate* isolate = env->isolate;

v8::EscapableHandleScope scope(isolate);

v8::Local<v8::Context> context = GetV8ModuleContext(env, state);

v8::Context::Scope contextScope(context);

v8::Local<v8::Module> module = state->module.Get(isolate);

if (module.IsEmpty() || module->GetStatus() < v8::Module::kInstantiated) {

return {};

}

v8::Local<v8::Object> ns = module->GetModuleNamespace().As<v8::Object>();

return CollectV8OwnStringKeys(isolate, context, ns);

}

bool ThrowV8ModuleException(napi_env env, ModuleState* state) {

v8::Isolate* isolate = env->isolate;

v8::HandleScope scope(isolate);

v8::Local<v8::Module> module = state->module.Get(isolate);

napi_throw(env, v8impl::JsValueFromV8LocalValue(module->GetException()));

return false;

}

bool CacheV8ModuleError(napi_env env, ModuleState* state) {

v8::Isolate* isolate = env->isolate;

v8::HandleScope scope(isolate);

v8::Local<v8::Module> module = state->module.Get(isolate);

return SetModuleError(