@nocobase/plugin-workflow-javascript 2.1.0-beta.10 → 2.1.0-beta.12

package/dist/node_modules/isolated-vm/src/isolate/strings.h

@@ -0,0 +1,127 @@
+#pragma once
+#include "isolate/generic/error.h"
+#include "isolate/generic/handle_cast.h"
+#include <v8.h>
+
+namespace ivm {
+
+class StringTable {
+	public:
+		class String {
+			public:
+				String(const char* value) : value{value} {} // NOLINT(hicpp-explicit-conversions)
+				String(const String&) = delete;
+				String(String&&) = delete;
+				~String() = default;
+				auto operator=(const String&) = delete;
+				auto operator=(String&&) = delete;
+
+				operator v8::Local<v8::Name>() { // NOLINT(hicpp-explicit-conversions)
+					return v8::Local<v8::String>{*this}.As<v8::Name>();
+				}
+
+				operator v8::Local<v8::Value>() { // NOLINT(hicpp-explicit-conversions)
+					return v8::Local<v8::String>{*this}.As<v8::Value>();
+				}
+
+				operator v8::Local<v8::String>() { // NOLINT(hicpp-explicit-conversions)
+					auto* isolate = v8::Isolate::GetCurrent();
+					if (handle.IsEmpty()) {
+						auto local = Unmaybe(v8::String::NewFromOneByte(
+							isolate, (const uint8_t*)value, v8::NewStringType::kInternalized));
+						handle.Set(isolate, local);
+						return local;
+					} else {
+						return handle.Get(isolate);
+					}
+				}
+
+			private:
+				const char* value;
+				v8::Eternal<v8::String> handle;
+		};
+
+		static auto Get() -> auto&;
+
+		// StringTable::Get().
+		String accessors{"accessors"};
+		String arguments{"arguments"};
+		String async{"async"};
+		String boolean{"boolean"};
+		String cachedData{"cachedData"};
+		String cachedDataRejected{"cachedDataRejected"};
+		String code{"code"};
+		// String codeGenerationError{"Code generation from large string was denied"};
+		String colonSpace{": "};
+		String columnOffset{"columnOffset"};
+		String copy{"copy"};
+		String externalCopy{"externalCopy"};
+		String filename{"filename"};
+		String function{"function"};
+		String global{"global"};
+		String ignored{"ignored"};
+		String inspector{"inspector"};
+		String isolateIsDisposed{"Isolate is disposed"};
+		String isolatedVm{"isolated-vm"};
+		String length{"length"};
+		String lineOffset{"lineOffset"};
+		String message{"message"};
+		String meta{"meta"};
+		String name{"name"};
+		String null{"null"};
+		String number{"number"};
+		String object{"object"};
+		String onCatastrophicError{"onCatastrophicError"};
+		String produceCachedData{"produceCachedData"};
+		String promise{"promise"};
+		String reference{"reference"};
+		String release{"release"};
+		String result{"result"};
+		String snapshot{"snapshot"};
+		String stack{"stack"};
+		String string{"string"};
+		String timeout{"timeout"};
+		String transferIn{"transferIn"};
+		String transferList{"transferList"};
+		String transferOut{"transferOut"};
+		String undefined{"undefined"};
+		String unsafeInherit{"unsafeInherit"};
+
+		String does_zap_garbage{"does_zap_garbage"};
+		String externally_allocated_size{"externally_allocated_size"};
+		String heap_size_limit{"heap_size_limit"};
+		String malloced_memory{"malloced_memory"};
+		String peak_malloced_memory{"peak_malloced_memory"};
+		String total_available_size{"total_available_size"};
+		String total_heap_size{"total_heap_size"};
+		String total_heap_size_executable{"total_heap_size_executable"};
+		String total_physical_size{"total_physical_size"};
+		String used_heap_size{"used_heap_size"};
+
+		// CPU Profiler specific keys
+		String threadId{"threadId"};
+		String profile{"profile"};
+		String startTime{"startTime"};
+		String endTime{"endTime"};
+		String samples{"samples"};
+		String timeDeltas{"timeDeltas"};
+		String nodes{"nodes"};
+		String id{"id"};
+		String callFrame{"callFrame"};
+		String functionName{"functionName"};
+		String scriptId{"scriptId"};
+		String url{"url"};
+		String lineNumber{"lineNumber"};
+		String columnNumber{"columnNumber"};
+		String hitCount{"hitCount"};
+		String children{"children"};
+		String title{"title"};
+		String bailoutReason{"bailoutReason"};
+};
+
+inline auto HandleCastImpl(
+		StringTable::String& value, const HandleCastArguments& /*arguments*/, HandleCastTag<v8::Local<v8::String>> /*tag*/) {
+	return v8::Local<v8::String>{value};
+}
+
+} // namespace ivm

package/dist/node_modules/isolated-vm/src/isolate/three_phase_task.cc

@@ -0,0 +1,385 @@
+#include "three_phase_task.h"
+#include "external_copy/external_copy.h"
+#include <cstring>
+
+using namespace v8;
+using std::unique_ptr;
+
+namespace ivm {
+
+/**
+ * CalleeInfo implementation
+ */
+ThreePhaseTask::CalleeInfo::CalleeInfo(
+	Local<Promise::Resolver> resolver,
+	Local<Context> context,
+	Local<StackTrace> stack_trace
+) : remotes(resolver, context, stack_trace) {
+	auto& env = IsolateEnvironment::GetCurrent();
+	if (env.IsDefault()) {
+		async = node::EmitAsyncInit(env.GetIsolate(), resolver->GetPromise(), StringTable::Get().isolatedVm);
+	}
+}
+
+ThreePhaseTask::CalleeInfo::CalleeInfo(CalleeInfo&& that) noexcept :
+		remotes{std::move(that.remotes)}, async{std::exchange(that.async, {0, 0})} {}
+
+ThreePhaseTask::CalleeInfo::~CalleeInfo() {
+	auto& env = IsolateEnvironment::GetCurrent();
+	node::async_context tmp{0, 0};
+	if (env.IsDefault() && std::memcmp(&async, &tmp, sizeof(node::async_context)) != 0) {
+		node::EmitAsyncDestroy(env.GetIsolate(), async);
+	}
+}
+
+/**
+ * Wrapper around node's version of the same class which does nothing if this isn't the node
+ * isolate.
+ *
+ * nb: CallbackScope sets up a v8::TryCatch so if you need to catch an exception do this *before*
+ * the v8::TryCatch.
+ */
+struct CallbackScope {
+	unique_ptr<node::CallbackScope> scope;
+
+	CallbackScope(node::async_context async, Local<Object> resource) {
+		auto& env = IsolateEnvironment::GetCurrent();
+		if (env.IsDefault()) {
+			scope = std::make_unique<node::CallbackScope>(env.GetIsolate(), resource, async);
+		}
+	}
+};
+
+/**
+ * Phase2Runner implementation
+ */
+ThreePhaseTask::Phase2Runner::Phase2Runner(
+	unique_ptr<ThreePhaseTask> self,
+	CalleeInfo info
+) :
+	self(std::move(self)),
+	info(std::move(info))	{}
+
+ThreePhaseTask::Phase2Runner::~Phase2Runner() {
+	if (!did_run) {
+		// The task never got to run
+		struct Phase3Orphan : public Runnable {
+			unique_ptr<ThreePhaseTask> self;
+			CalleeInfo info;
+
+			Phase3Orphan(
+				unique_ptr<ThreePhaseTask> self,
+				CalleeInfo info
+			) :
+				self(std::move(self)),
+				info(std::move(info)) {}
+
+			void Run() final {
+				// Revive our persistent handles
+				Isolate* isolate = Isolate::GetCurrent();
+				auto context_local = info.remotes.Deref<1>();
+				Context::Scope context_scope(context_local);
+				auto promise_local = info.remotes.Deref<0>();
+				CallbackScope callback_scope(info.async, promise_local);
+				// Throw from promise
+				Local<Object> error = Exception::Error(StringTable::Get().isolateIsDisposed).As<Object>();
+				StackTraceHolder::AttachStack(error, info.remotes.Deref<2>());
+				Unmaybe(promise_local->Reject(context_local, error));
+				isolate->PerformMicrotaskCheckpoint();
+			}
+		};
+		// Schedule a throw task back in first isolate
+		auto* holder = info.remotes.GetIsolateHolder();
+		holder->ScheduleTask(
+			std::make_unique<Phase3Orphan>(
+				std::move(self),
+				std::move(info)
+			), false, true
+		);
+	}
+}
+
+void ThreePhaseTask::Phase2Runner::Run() {
+
+	// This class will be used if Phase2() throws an error
+	struct Phase3Failure : public Runnable {
+		unique_ptr<ThreePhaseTask> self;
+		CalleeInfo info;
+		unique_ptr<ExternalCopy> error;
+
+		Phase3Failure(
+			unique_ptr<ThreePhaseTask> self,
+			CalleeInfo info,
+			unique_ptr<ExternalCopy> error
+		) :
+			self(std::move(self)),
+			info(std::move(info)),
+			error(std::move(error)) {}
+
+		void Run() final {
+			// Revive our persistent handles
+			Isolate* isolate = Isolate::GetCurrent();
+			auto context_local = info.remotes.Deref<1>();
+			Context::Scope context_scope(context_local);
+			auto promise_local = info.remotes.Deref<0>();
+			CallbackScope callback_scope(info.async, promise_local);
+			Local<Value> rejection;
+			if (error) {
+				rejection = error->CopyInto();
+			} else {
+				rejection = Exception::Error(v8_string("An exception was thrown. Sorry I don't know more."));
+			}
+			if (rejection->IsObject()) {
+				StackTraceHolder::ChainStack(rejection.As<Object>(), info.remotes.Deref<2>());
+			}
+			// If Reject fails then I think that's bad..
+			Unmaybe(promise_local->Reject(context_local, rejection));
+				isolate->PerformMicrotaskCheckpoint();
+		}
+	};
+
+	// This is called if Phase2() does not throw
+	struct Phase3Success : public Runnable {
+		unique_ptr<ThreePhaseTask> self;
+		CalleeInfo info;
+
+		Phase3Success(
+			unique_ptr<ThreePhaseTask> self,
+			CalleeInfo info
+		) :
+			self(std::move(self)),
+			info(std::move(info)) {}
+
+		void Run() final {
+			Isolate* isolate = Isolate::GetCurrent();
+			auto context_local = info.remotes.Deref<1>();
+			Context::Scope context_scope(context_local);
+			auto promise_local = info.remotes.Deref<0>();
+			CallbackScope callback_scope(info.async, promise_local);
+			FunctorRunners::RunCatchValue([&]() {
+				// Final callback
+				Unmaybe(promise_local->Resolve(context_local, self->Phase3()));
+			}, [&](Local<Value> error) {
+				// Error was thrown
+				if (error->IsObject()) {
+					StackTraceHolder::AttachStack(error.As<Object>(), info.remotes.Deref<2>());
+				}
+				Unmaybe(promise_local->Reject(context_local, error));
+			});
+			isolate->PerformMicrotaskCheckpoint();
+		}
+	};
+
+	did_run = true;
+	auto schedule_error = [&](std::unique_ptr<ExternalCopy> error) {
+		// Schedule a task to enter the first isolate so we can throw the error at the promise
+		auto* holder = info.remotes.GetIsolateHolder();
+		holder->ScheduleTask(std::make_unique<Phase3Failure>(std::move(self), std::move(info), std::move(error)), false, true);
+	};
+	FunctorRunners::RunCatchExternal(IsolateEnvironment::GetCurrent().DefaultContext(), [&]() {
+		// Continue the task
+		self->Phase2();
+		auto epilogue_error = IsolateEnvironment::GetCurrent().TaskEpilogue();
+		if (epilogue_error) {
+			schedule_error(std::move(epilogue_error));
+		} else {
+			auto* holder = info.remotes.GetIsolateHolder();
+			holder->ScheduleTask(std::make_unique<Phase3Success>(std::move(self), std::move(info)), false, true);
+		}
+	}, schedule_error);
+}
+
+/**
+ * Phase2RunnerIgnored implementation
+ */
+ThreePhaseTask::Phase2RunnerIgnored::Phase2RunnerIgnored(unique_ptr<ThreePhaseTask> self) : self(std::move(self)) {}
+
+void ThreePhaseTask::Phase2RunnerIgnored::Run() {
+	TryCatch try_catch{Isolate::GetCurrent()};
+	try {
+		self->Phase2();
+		IsolateEnvironment::GetCurrent().TaskEpilogue();
+	} catch (const RuntimeError& cc_error) {}
+}
+
+/**
+ * RunSync implementation
+ */
+auto ThreePhaseTask::RunSync(IsolateHolder& second_isolate, bool allow_async) -> Local<Value> {
+	// Grab a reference to second isolate
+	auto second_isolate_ref = second_isolate.GetIsolate();
+	if (!second_isolate_ref) {
+		throw RuntimeGenericError("Isolated is disposed");
+	}
+	if (second_isolate_ref->GetIsolate() == Isolate::GetCurrent()) {
+		if (allow_async) {
+			throw RuntimeGenericError("This function may not be called from the default thread");
+		}
+		// Shortcut when calling a sync method belonging to the currently entered isolate. This avoids
+		// the deadlock protection below
+		Phase2();
+		second_isolate_ref->CheckMemoryPressure();
+
+	} else {
+
+		bool is_recursive = Locker::IsLocked(second_isolate_ref->GetIsolate());
+		if (Executor::IsDefaultThread() || is_recursive) {
+			if (allow_async) {
+				throw RuntimeGenericError("This function may not be called from the default thread");
+			}
+
+			// Helper function which flushes handle tasks
+			auto run_handle_tasks = [](IsolateEnvironment& env) {
+				auto handle_tasks = [&]() {
+					return ExchangeDefault(env.scheduler->Lock()->handle_tasks);
+				}();
+				if (handle_tasks.empty()) {
+					return;
+				}
+				do {
+					handle_tasks.front()->Run();
+					handle_tasks.pop();
+				} while (!handle_tasks.empty());
+			};
+
+			// This is the simple sync runner case
+			unique_ptr<ExternalCopy> error;
+			{
+				Executor::Lock lock(*second_isolate_ref);
+
+				// Run handle tasks first
+				run_handle_tasks(*second_isolate_ref);
+
+				// Now run the actual work
+				FunctorRunners::RunCatchExternal(second_isolate_ref->DefaultContext(), [&]() {
+					// Run Phase2 and externalize errors
+					Phase2();
+					if (!is_recursive) {
+						error = second_isolate_ref->TaskEpilogue();
+					}
+				}, [&](unique_ptr<ExternalCopy> error_inner) {
+
+					// We need to stash the error in the outer unique_ptr because the executor lock is still up
+					error = std::move(error_inner);
+				});
+			}
+
+			// Run handle tasks for default isolate now
+			auto& current_env = IsolateEnvironment::GetCurrent();
+			if (current_env.IsDefault()) {
+				run_handle_tasks(current_env);
+			}
+
+			if (error) {
+				// Throw to outer isolate
+				Isolate* isolate = Isolate::GetCurrent();
+				Local<Value> error_copy = error->CopyInto();
+				if (error_copy->IsObject()) {
+					StackTraceHolder::ChainStack(error_copy.As<Object>(), StackTrace::CurrentStackTrace(isolate, 10));
+				}
+				isolate->ThrowException(error_copy);
+				throw RuntimeError();
+			}
+
+		} else if (second_isolate_ref->IsDefault()) {
+
+			// In this case we asyncronously call the default thread and suspend this thread
+			struct AsyncRunner final : public Runnable {
+				bool allow_async = false;
+				bool did_run = false;
+				ThreePhaseTask& self;
+				Scheduler::AsyncWait& wait;
+				lockable_t<bool, false, true>& done;
+				unique_ptr<ExternalCopy>& error;
+
+				AsyncRunner(
+					ThreePhaseTask& self,
+					Scheduler::AsyncWait& wait,
+					lockable_t<bool, false, true>& done,
+					bool allow_async,
+					unique_ptr<ExternalCopy>& error
+				) : allow_async{allow_async}, self{self}, wait{wait}, done{done}, error{error} {}
+
+				AsyncRunner(const AsyncRunner&) = delete;
+				auto operator=(const AsyncRunner&) -> AsyncRunner& = delete;
+
+				~AsyncRunner() final {
+					if (!did_run) {
+						error = std::make_unique<ExternalCopyError>(ExternalCopyError::ErrorType::Error, "Isolate is disposed");
+					}
+					// nb: The lock must be held while invoking `notify_one` since the condition variable will
+					// be destroyed immediately following the wake.
+					auto lock = done.write();
+					*lock = true;
+					done.notify_one();
+				}
+
+				void Run() final {
+					did_run = true;
+					FunctorRunners::RunCatchExternal(IsolateEnvironment::GetCurrent().DefaultContext(), [ this ]() {
+						// Now in the default thread
+						const auto is_async = [&]() {
+							if (allow_async) {
+								return self.Phase2Async(wait);
+							} else {
+								self.Phase2();
+								return false;
+							}
+						}();
+						if (!is_async) {
+							wait.Done();
+						}
+						this->error = IsolateEnvironment::GetCurrent().TaskEpilogue();
+					}, [ this ](unique_ptr<ExternalCopy> error) {
+						this->error = std::move(error);
+						wait.Done();
+					});
+				}
+			};
+
+			Isolate* isolate = Isolate::GetCurrent();
+			unique_ptr<ExternalCopy> error;
+			{
+				// Setup condition variable to sleep this thread
+				IsolateEnvironment& env = IsolateEnvironment::GetCurrent();
+				Scheduler::AsyncWait wait(*env.scheduler);
+				lockable_t<bool, false, true> done{false};
+				// Scope to unlock v8 in this thread and set up the wait
+				Executor::Unlock unlocker(env);
+				// Run it and sleep
+				second_isolate.ScheduleTask(std::make_unique<AsyncRunner>(*this, wait, done, allow_async, error), false, true);
+				// Wait for AsyncRunner to finish
+				auto lock = done.read<true>();
+				while (!*lock) {
+					lock.wait();
+				}
+				// Wait for `applySyncPromise` to finish
+				if (wait.Wait() == Scheduler::AsyncWait::canceled) {
+					throw RuntimeGenericError("Isolate is disposed");
+				}
+			}
+
+			// At this point thread synchronization is done and Phase2() has finished
+			if (error) {
+				Local<Value> error_copy = error->CopyInto();
+				if (error_copy->IsObject()) {
+					StackTraceHolder::ChainStack(error_copy.As<Object>(), StackTrace::CurrentStackTrace(isolate, 10));
+				}
+				isolate->ThrowException(error_copy);
+				throw RuntimeError();
+			}
+
+		} else {
+
+			// ~ very specific error message ~
+			throw RuntimeGenericError(
+				"Calling a synchronous isolated-vm function on a non-default isolate from within an asynchronous isolated-vm function is not allowed."
+			);
+		}
+	}
+
+	// Final phase
+	return Phase3();
+}
+
+} // namespace ivm

package/dist/node_modules/isolated-vm/src/isolate/three_phase_task.h

@@ -0,0 +1,136 @@
+#pragma once
+#include "node_wrapper.h"
+#include "environment.h"
+#include "holder.h"
+#include "functor_runners.h"
+#include "remote_handle.h"
+#include "stack_trace.h"
+#include "util.h"
+#include <memory>
+
+namespace ivm {
+
+/**
+ * Most operations in this library can be decomposed into three phases.
+ *
+ * - Phase 1 [Isolate 1]: copy data out of current isolate
+ * - Phase 2 [Isolate 2]: copy data into new isolate, run work, copy data out of isolate
+ * - Phase 3 [Isolate 1]: copy results from phase 2 into the original isolate
+ *
+ * This class handles the locking and thread synchronization for either synchronous or
+ * asynchronous functions. That way the same code can be used for both versions of each function.
+ *
+ * These runners are invoked via: ThreePhaseTask::Run<async, T>(isolate, args...);
+ *
+ * Where:
+ *   async = 0 -- Synchronous execution
+ *   async = 1 -- Asynchronous execution, promise returned
+ *   async = 2 -- Asynchronous execution, result ignored (Phase3() is never called)
+ *   async = 4 -- Synchronous + asyncronous, original thread waits for async Phase2()
+ */
+class ThreePhaseTask {
+	private:
+		/**
+		 * Contains references back to the original isolate which will be used after phase 2 to wake the
+		 * isolate up and begin phase 3
+		 */
+		struct CalleeInfo {
+			RemoteTuple<v8::Promise::Resolver, v8::Context, v8::StackTrace> remotes;
+			node::async_context async {0, 0};
+			CalleeInfo(
+				v8::Local<v8::Promise::Resolver> resolver,
+				v8::Local<v8::Context> context,
+				v8::Local<v8::StackTrace> stack_trace
+			);
+			CalleeInfo(const CalleeInfo&) = delete;
+			CalleeInfo(CalleeInfo&& /*that*/) noexcept;
+			auto operator= (const CalleeInfo&) = delete;
+			auto operator= (CalleeInfo&&) = delete;
+			~CalleeInfo();
+		};
+
+		/**
+		 * Class which manages running async phase 2, then phase 3
+		 */
+		struct Phase2Runner final : public Runnable {
+			std::unique_ptr<ThreePhaseTask> self;
+			CalleeInfo info;
+			bool did_run = false;
+
+			Phase2Runner(
+				std::unique_ptr<ThreePhaseTask> self,
+				CalleeInfo info
+			);
+			Phase2Runner(const Phase2Runner&) = delete;
+			auto operator= (const Phase2Runner&) -> Phase2Runner& = delete;
+			~Phase2Runner() final;
+			void Run() final;
+		};
+
+		/**
+		 * Class which manages running async phase 2 in ignored mode (ie no phase 3)
+		 */
+		struct Phase2RunnerIgnored : public Runnable {
+			std::unique_ptr<ThreePhaseTask> self;
+			explicit Phase2RunnerIgnored(std::unique_ptr<ThreePhaseTask> self);
+			void Run() final;
+		};
+
+		auto RunSync(IsolateHolder& second_isolate, bool allow_async) -> v8::Local<v8::Value>;
+
+	public:
+		ThreePhaseTask() = default;
+		ThreePhaseTask(const ThreePhaseTask&) = delete;
+		auto operator= (const ThreePhaseTask&) -> ThreePhaseTask& = delete;
+		virtual ~ThreePhaseTask() = default;
+
+		virtual void Phase2() = 0;
+		virtual auto Phase2Async(Scheduler::AsyncWait& /*wait*/) -> bool {
+			Phase2();
+			return false;
+		}
+
+		virtual auto Phase3() -> v8::Local<v8::Value> = 0;
+
+		template <int async, typename T, typename ...Args>
+		static auto Run(IsolateHolder& second_isolate, Args&&... args) -> v8::Local<v8::Value> {
+
+			if (async == 1) { // Full async, promise returned
+				// Build a promise for outer isolate
+				v8::Isolate* isolate = v8::Isolate::GetCurrent();
+				auto context_local = isolate->GetCurrentContext();
+				auto promise_local = Unmaybe(v8::Promise::Resolver::New(context_local));
+				auto stack_trace = v8::StackTrace::CurrentStackTrace(isolate, 10);
+				FunctorRunners::RunCatchValue([&]() {
+					// Schedule Phase2 async
+					second_isolate.ScheduleTask(
+						std::make_unique<Phase2Runner>(
+							std::make_unique<T>(std::forward<Args>(args)...), // <-- Phase1 / ctor called here
+							CalleeInfo{promise_local, context_local, stack_trace}
+						), false, true
+					);
+				}, [&](v8::Local<v8::Value> error) {
+					// A C++ error was caught while running ctor (phase 1)
+					if (error->IsObject()) {
+						StackTraceHolder::AttachStack(error.As<v8::Object>(), stack_trace);
+					}
+					Unmaybe(promise_local->Reject(context_local, error));
+				});
+				return promise_local->GetPromise();
+			} else if (async == 2) { // Async, promise ignored
+				// Schedule Phase2 async
+				second_isolate.ScheduleTask(
+					std::make_unique<Phase2RunnerIgnored>(
+						std::make_unique<T>(std::forward<Args>(args)...) // <-- Phase1 / ctor called here
+					), false, true
+				);
+				return v8::Undefined(v8::Isolate::GetCurrent());
+			} else {
+				// Execute synchronously
+				T self(std::forward<Args>(args)...);
+				return self.RunSync(second_isolate, async == 4);
+			}
+		}
+};
+
+} // namespace ivm

package/dist/node_modules/isolated-vm/src/isolate/transferable.h

@@ -0,0 +1,15 @@
+#pragma once
+#include <v8.h>
+
+namespace ivm {
+
+class Transferable {
+	public:
+		Transferable() = default;
+		Transferable(const Transferable&) = delete;
+		auto operator= (const Transferable&) = delete;
+		virtual ~Transferable() = default;
+		virtual auto TransferIn() -> v8::Local<v8::Value> = 0;
+};
+
+} // namespace ivm

package/dist/node_modules/isolated-vm/src/isolate/util.h

@@ -0,0 +1,45 @@
+#pragma once
+#include <cassert>
+#include <string>
+#include <functional>
+#include <v8.h>
+#include "generic/error.h"
+
+namespace ivm {
+
+/**
+ * Easy strings
+ */
+inline auto v8_string(const char* string) -> v8::Local<v8::String> {
+	return Unmaybe(v8::String::NewFromOneByte(v8::Isolate::GetCurrent(), (const uint8_t*)string, v8::NewStringType::kNormal)); // NOLINT
+}
+
+inline auto v8_symbol(const char* string) -> v8::Local<v8::String> {
+	return Unmaybe(v8::String::NewFromOneByte(v8::Isolate::GetCurrent(), (const uint8_t*)string, v8::NewStringType::kInternalized)); // NOLINT
+}
+
+/**
+ * Shorthand dereference of Persistent to Local
+ */
+template <typename T>
+auto Deref(const v8::Persistent<T>& handle) -> v8::Local<T> {
+	return v8::Local<T>::New(v8::Isolate::GetCurrent(), handle);
+}
+
+template <typename T>
+auto Deref(const v8::Persistent<T, v8::CopyablePersistentTraits<T>>& handle) -> v8::Local<T> {
+	return v8::Local<T>::New(v8::Isolate::GetCurrent(), handle);
+}
+
+}
+
+#include "remote_handle.h"
+
+namespace ivm {
+
+template <typename T>
+auto Deref(const RemoteHandle<T>& handle) -> v8::Local<T> {
+	return handle.Deref();
+}
+
+} // namespace ivm