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

package/dist/node_modules/isolated-vm/src/module/context_handle.cc

@@ -0,0 +1,241 @@
+#include "isolate/run_with_timeout.h"
+#include "isolate/three_phase_task.h"
+#include "module/evaluation.h"
+#include "context_handle.h"
+#include "reference_handle.h"
+#include "transferable.h"
+
+using namespace v8;
+
+namespace ivm {
+namespace {
+
+/**
+ * Instances of this turn into a ContextHandle when they are transferred in
+ */
+class ContextHandleTransferable : public Transferable {
+	public:
+		ContextHandleTransferable(RemoteHandle<Context> context, RemoteHandle<Value> global) :
+			context{std::move(context)}, global{std::move(global)} {}
+
+		auto TransferIn() -> Local<Value> final {
+			return ClassHandle::NewInstance<ContextHandle>(std::move(context), std::move(global));
+		}
+
+	private:
+		RemoteHandle<v8::Context> context;
+		RemoteHandle<v8::Value> global;
+};
+
+} // anonymous namespace
+
+/**
+ * ContextHandle implementation
+ */
+ContextHandle::ContextHandle(RemoteHandle<Context> context, RemoteHandle<Value> global) :
+	context{std::move(context)}, global{std::move(global)} {}
+
+auto ContextHandle::Definition() -> Local<FunctionTemplate> {
+	return Inherit<TransferableHandle>(MakeClass(
+		"Context", nullptr,
+		"eval", MemberFunction<decltype(&ContextHandle::Eval<1>), &ContextHandle::Eval<1>>{},
+		"evalIgnored", MemberFunction<decltype(&ContextHandle::Eval<2>), &ContextHandle::Eval<2>>{},
+		"evalSync", MemberFunction<decltype(&ContextHandle::Eval<0>), &ContextHandle::Eval<0>>{},
+		"evalClosure", MemberFunction<decltype(&ContextHandle::EvalClosure<1>), &ContextHandle::EvalClosure<1>>{},
+		"evalClosureIgnored", MemberFunction<decltype(&ContextHandle::EvalClosure<2>), &ContextHandle::EvalClosure<2>>{},
+		"evalClosureSync", MemberFunction<decltype(&ContextHandle::EvalClosure<0>), &ContextHandle::EvalClosure<0>>{},
+		"global", MemberAccessor<decltype(&ContextHandle::GlobalGetter), &ContextHandle::GlobalGetter>{},
+		"release", MemberFunction<decltype(&ContextHandle::Release), &ContextHandle::Release>{}
+	));
+}
+
+auto ContextHandle::TransferOut() -> std::unique_ptr<Transferable> {
+	return std::make_unique<ContextHandleTransferable>(context, global);
+}
+
+auto ContextHandle::GetContext() const -> RemoteHandle<v8::Context> {
+	if (!context) {
+		throw RuntimeGenericError("Context is released");
+	}
+	return context;
+}
+
+auto ContextHandle::GlobalGetter() -> Local<Value> {
+	Isolate* isolate = Isolate::GetCurrent();
+	if (!context) {
+		return Undefined(isolate);
+	}
+	Local<Object> ref;
+	if (global_reference) {
+		ref = Deref(global_reference);
+	} else {
+		ref = ClassHandle::NewInstance<ReferenceHandle>(global.GetSharedIsolateHolder(), global, context, ReferenceHandle::TypeOf::Object, false, false);
+		global_reference = RemoteHandle<v8::Object>(ref);
+	}
+	Unmaybe(This()->CreateDataProperty(isolate->GetCurrentContext(), StringTable::Get().global, ref));
+	return ref;
+}
+
+auto ContextHandle::Release() -> Local<Value> {
+	return Boolean::New(Isolate::GetCurrent(), [&]() {
+		if (context) {
+			context = {};
+			global = {};
+			if (global_reference) {
+				ClassHandle::Unwrap<ReferenceHandle>(Deref(global_reference))->Release();
+				global_reference = {};
+			}
+			return true;
+		} else {
+			return false;
+		}
+	}());
+}
+
+/*
+ * Compiles and immediately executes a given script
+ */
+class EvalRunner : public CodeCompilerHolder, public ThreePhaseTask {
+	public:
+		explicit EvalRunner(
+			RemoteHandle<Context> context,
+			Local<String> code,
+			MaybeLocal<Object> maybe_options
+		) :
+				CodeCompilerHolder{code, maybe_options},
+				transfer_options{maybe_options},
+				context{std::move(context)} {
+			if (!this->context) {
+				throw RuntimeGenericError("Context is released");
+			}
+			timeout_ms = ReadOption<int32_t>(maybe_options, StringTable::Get().timeout, timeout_ms);
+		}
+
+		void Phase2() final {
+			// Load script in and compile
+			auto& isolate = IsolateEnvironment::GetCurrent();
+			auto context = this->context.Deref();
+			Context::Scope context_scope{context};
+			IsolateEnvironment::HeapCheck heap_check{isolate, true};
+			auto source = GetSource();
+			auto script = RunWithAnnotatedErrors([&]() {
+				return Unmaybe(ScriptCompiler::Compile(context, source.get()));
+			});
+
+			// Execute script and transfer out
+			Local<Value> script_result = RunWithTimeout(timeout_ms, [&]() {
+				return script->Run(context);
+			});
+			result = OptionalTransferOut(script_result, transfer_options);
+			heap_check.Epilogue();
+		}
+
+		auto Phase3() -> Local<Value> final {
+			return result ? result->TransferIn() : Undefined(Isolate::GetCurrent()).As<Value>();
+		}
+
+	private:
+		TransferOptions transfer_options;
+		RemoteHandle<Context> context;
+		std::unique_ptr<Transferable> result;
+		int32_t timeout_ms = 0;
+};
+
+template <int Async>
+auto ContextHandle::Eval(Local<String> code, MaybeLocal<Object> maybe_options) -> Local<Value> {
+	return ThreePhaseTask::Run<Async, EvalRunner>(*context.GetIsolateHolder(), context, code, maybe_options);
+}
+
+/*
+ * Compiles a script as a function body and immediately invokes it
+ */
+class EvalClosureRunner : public CodeCompilerHolder, public ThreePhaseTask {
+	public:
+		explicit EvalClosureRunner(
+			RemoteHandle<Context> context,
+			Local<String> code,
+			Maybe<ArrayRange> maybe_arguments,
+			MaybeLocal<Object> maybe_options
+		) :
+				CodeCompilerHolder{code, maybe_options},
+				transfer_options{ReadOption<MaybeLocal<Object>>(maybe_options, StringTable::Get().result, {})},
+				argv{[&]() {
+					// Transfer arguments out of isolate
+					std::vector<std::unique_ptr<Transferable>> argv;
+					TransferOptions transfer_options{ReadOption<MaybeLocal<Object>>(maybe_options, StringTable::Get().arguments, {})};
+					ArrayRange arguments;
+					if (maybe_arguments.To(&arguments)) {
+						argv.reserve(std::distance(arguments.begin(), arguments.end()));
+						for (auto value : arguments) {
+							argv.push_back(TransferOut(value, transfer_options));
+						}
+					}
+					return argv;
+				}()},
+				context{std::move(context)} {
+			if (!this->context) {
+				throw RuntimeGenericError("Context is released");
+			}
+			timeout_ms = ReadOption<int32_t>(maybe_options, StringTable::Get().timeout, timeout_ms);
+		}
+
+		void Phase2() final {
+			// Setup isolate's context
+			auto& isolate = IsolateEnvironment::GetCurrent();
+			auto context = this->context.Deref();
+			Context::Scope context_scope{context};
+			IsolateEnvironment::HeapCheck heap_check{isolate, true};
+
+			// Generate $0 ... $N argument names
+			std::vector<Local<String>> argument_names;
+			size_t argc = argv.size();
+			argument_names.reserve(argc + 1);
+			for (size_t ii = 0; ii < argc; ++ii) {
+				argument_names.emplace_back(HandleCast<Local<String>>(std::string{"$"}+ std::to_string(ii)));
+			}
+
+			// Invoke `new Function` to compile script
+			auto source = GetSource();
+			auto function = RunWithAnnotatedErrors([&]() {
+				return Unmaybe(ScriptCompiler::CompileFunction(
+					context, source.get(),
+					argument_names.size(), argument_names.empty() ? nullptr : &argument_names[0],
+					0, nullptr
+				));
+			});
+
+			// Transfer arguments into this isolate
+			std::vector<Local<Value>> argv_transferred;
+			argv_transferred.reserve(argc);
+			for (size_t ii = 0; ii < argc; ++ii) {
+				argv_transferred.emplace_back(argv[ii]->TransferIn());
+			}
+
+			// Execute script and transfer out
+			Local<Value> script_result = RunWithTimeout(timeout_ms, [&]() {
+				return function->Call(
+					context, context->Global(),
+					argv_transferred.size(), argv_transferred.empty() ? nullptr : &argv_transferred[0]);
+			});
+			result = TransferOut(script_result, transfer_options);
+			heap_check.Epilogue();
+		}
+
+		auto Phase3() -> Local<Value> final {
+			return result ? result->TransferIn() : Undefined(Isolate::GetCurrent()).As<Value>();
+		}
+
+	private:
+		TransferOptions transfer_options;
+		std::vector<std::unique_ptr<Transferable>> argv;
+		RemoteHandle<Context> context;
+		std::unique_ptr<Transferable> result;
+		int32_t timeout_ms = 0;
+};
+
+template <int Async>
+auto ContextHandle::EvalClosure(Local<String> code, Maybe<ArrayRange> maybe_arguments, MaybeLocal<Object> maybe_options) -> Local<Value> {
+	return ThreePhaseTask::Run<Async, EvalClosureRunner>(*context.GetIsolateHolder(), context, code, maybe_arguments, maybe_options);
+}
+
+} // namespace ivm

package/dist/node_modules/isolated-vm/src/module/context_handle.h

@@ -0,0 +1,35 @@
+#pragma once
+#include "isolate/remote_handle.h"
+#include "transferable.h"
+#include <v8.h>
+#include <memory>
+
+namespace ivm {
+
+class ContextHandle : public TransferableHandle {
+	public:
+		ContextHandle(RemoteHandle<v8::Context> context, RemoteHandle<v8::Value> global);
+		static auto Definition() -> v8::Local<v8::FunctionTemplate>;
+		auto TransferOut() -> std::unique_ptr<Transferable> final;
+
+		auto GetContext() const -> RemoteHandle<v8::Context>;
+		auto GlobalGetter() -> v8::Local<v8::Value>;
+		auto Release() -> v8::Local<v8::Value>;
+
+		template <int Async>
+		auto Eval(v8::Local<v8::String> code, v8::MaybeLocal<v8::Object> maybe_options) -> v8::Local<v8::Value>;
+
+		template <int Async>
+		auto EvalClosure(
+			v8::Local<v8::String> code,
+			v8::Maybe<ArrayRange> maybe_arguments,
+			v8::MaybeLocal<v8::Object> maybe_options
+		) -> v8::Local<v8::Value>;
+
+	private:
+		RemoteHandle<v8::Context> context;
+		RemoteHandle<v8::Value> global;
+		RemoteHandle<v8::Object> global_reference;
+};
+
+} // namespace ivm

package/dist/node_modules/isolated-vm/src/module/evaluation.cc

@@ -0,0 +1,109 @@
+#include "isolate/class_handle.h"
+#include "isolate/generic/read_option.h"
+#include "external_copy_handle.h"
+#include "evaluation.h"
+
+using namespace v8;
+namespace ivm {
+
+/**
+ * ScriptOriginHolder implementation
+ */
+ScriptOriginHolder::ScriptOriginHolder(MaybeLocal<Object> maybe_options, bool is_module) :
+		is_module{is_module} {
+	Local<Object> options;
+	if (maybe_options.ToLocal(&options)) {
+		filename = ReadOption<std::string>(options, StringTable::Get().filename, filename);
+		column_offset = ReadOption<int32_t>(options, StringTable::Get().columnOffset, column_offset);
+		line_offset = ReadOption<int32_t>(options, StringTable::Get().lineOffset, line_offset);
+	}
+}
+
+ScriptOriginHolder::operator ScriptOrigin() const {
+	return ScriptOrigin{
+			Isolate::GetCurrent(),
+			HandleCast<Local<String>>(filename),
+			line_offset,
+			column_offset,
+			false, // resource_is_shared_cross_origin
+			-1, // script_id
+			{}, // source_map_url
+			false, // resource_is_opaque
+			false, // is_wasm
+			is_module
+	};
+}
+
+/**
+ * CodeCompilerHolder implementation
+ */
+CodeCompilerHolder::CodeCompilerHolder(Local<String> code_handle, MaybeLocal<Object> maybe_options, bool is_module) :
+		script_origin_holder{maybe_options, is_module},
+		code_string{ExternalCopyString{code_handle}},
+		produce_cached_data{ReadOption<bool>(maybe_options, StringTable::Get().produceCachedData, {})} {
+	// Read `cachedData`
+	auto maybe_cached_data = ReadOption<MaybeLocal<Object>>(maybe_options, StringTable::Get().cachedData, {});
+	Local<Object> cached_data;
+	if (maybe_cached_data.ToLocal(&cached_data)) {
+		auto* copy_handle = ClassHandle::Unwrap<ExternalCopyHandle>(cached_data);
+		if (copy_handle != nullptr) {
+			ExternalCopyArrayBuffer* copy_ptr = dynamic_cast<ExternalCopyArrayBuffer*>(copy_handle->GetValue().get());
+			if (copy_ptr != nullptr) {
+				supplied_cached_data = true;
+				cached_data_in = copy_ptr->Acquire();
+				cached_data_in_size = cached_data_in->ByteLength();
+			}
+		}
+		if (!cached_data_in) {
+			throw RuntimeTypeError("`cachedData` must be an ExternalCopy to ArrayBuffer");
+		}
+	}
+}
+
+auto CodeCompilerHolder::GetCachedData() const -> std::unique_ptr<ScriptCompiler::CachedData> {
+	if (cached_data_in) {
+		return std::make_unique<ScriptCompiler::CachedData>(reinterpret_cast<const uint8_t*>(cached_data_in->Data()), cached_data_in_size);
+	}
+	return {};
+}
+
+auto CodeCompilerHolder::GetSource() -> std::unique_ptr<ScriptCompiler::Source> {
+	return std::make_unique<ScriptCompiler::Source>(
+		GetSourceString(),
+		ScriptOrigin{script_origin_holder},
+		GetCachedData().release()
+	);
+}
+
+auto CodeCompilerHolder::GetSourceString() -> v8::Local<v8::String> {
+	if (code_string_handle.IsEmpty()) {
+		code_string_handle = code_string.CopyIntoCheckHeap().As<String>();
+	}
+	return code_string_handle;
+}
+
+void CodeCompilerHolder::ResetSource() {
+	cached_data_in.reset();
+	code_string = {};
+}
+
+void CodeCompilerHolder::SaveCachedData(ScriptCompiler::CachedData* cached_data) {
+	if (cached_data != nullptr) {
+		cached_data_out = std::make_shared<ExternalCopyArrayBuffer>((void*)cached_data->data, cached_data->length);
+		cached_data->buffer_policy = ScriptCompiler::CachedData::BufferNotOwned;
+		delete cached_data;
+	}
+}
+
+void CodeCompilerHolder::WriteCompileResults(Local<Object> handle) {
+	Isolate* isolate = Isolate::GetCurrent();
+	Local<Context> context = isolate->GetCurrentContext();
+	if (DidSupplyCachedData()) {
+		Unmaybe(handle->Set(context, StringTable::Get().cachedDataRejected, Boolean::New(isolate, cached_data_rejected)));
+	}
+	if (cached_data_out) {
+		Unmaybe(handle->Set(context, StringTable::Get().cachedData, ClassHandle::NewInstance<ExternalCopyHandle>(std::move(cached_data_out))));
+	}
+}
+
+} // namespace ivm

package/dist/node_modules/isolated-vm/src/module/evaluation.h

@@ -0,0 +1,99 @@
+#pragma once
+#include "isolate/generic/error.h"
+#include "isolate/generic/handle_cast.h"
+#include "external_copy/external_copy.h"
+#include "external_copy/string.h"
+#include <v8.h>
+#include <memory>
+#include <string>
+
+namespace ivm {
+
+/**
+ * Parses script origin information from an option object and returns a non-v8 holder for the
+ * information which can then be converted to a ScriptOrigin, perhaps in a different isolate from
+ * the one it was read in.
+ */
+class ScriptOriginHolder {
+	public:
+		explicit ScriptOriginHolder(v8::MaybeLocal<v8::Object> maybe_options, bool is_module = false);
+		explicit operator v8::ScriptOrigin() const;
+
+	private:
+		std::string filename = "<isolated-vm>";
+		int32_t column_offset = 0;
+		int32_t line_offset = 0;
+		bool is_module;
+};
+
+/**
+ * Parser and holder for all common v8 compilation information like code string, cached data, script
+ * origin, etc.
+ */
+class CodeCompilerHolder {
+	public:
+		CodeCompilerHolder(
+			v8::Local<v8::String> code_handle, v8::MaybeLocal<v8::Object> maybe_options, bool is_module = false);
+		auto DidSupplyCachedData() const { return supplied_cached_data; }
+		auto GetSource() -> std::unique_ptr<v8::ScriptCompiler::Source>;
+		auto GetSourceString() -> v8::Local<v8::String>;
+		void ResetSource();
+		void SaveCachedData(v8::ScriptCompiler::CachedData* cached_data);
+		void SetCachedDataRejected(bool rejected) { cached_data_rejected = rejected; }
+		auto ShouldProduceCachedData() const { return produce_cached_data && (!supplied_cached_data || cached_data_rejected); }
+		void WriteCompileResults(v8::Local<v8::Object> handle);
+
+	private:
+		auto GetCachedData() const -> std::unique_ptr<v8::ScriptCompiler::CachedData>;
+
+		ScriptOriginHolder script_origin_holder;
+		ExternalCopyString code_string;
+		std::shared_ptr<ExternalCopyArrayBuffer> cached_data_out;
+		std::shared_ptr<v8::BackingStore> cached_data_in;
+		mutable v8::Local<v8::String> code_string_handle;
+		size_t cached_data_in_size = 0;
+		bool cached_data_rejected = false;
+		bool produce_cached_data = false;
+		bool supplied_cached_data = false;
+};
+
+/**
+ * Run a lambda which invokes the v8 compiler and annotate the exception with source / line number
+ * if it throws.
+ */
+template <class Function>
+auto RunWithAnnotatedErrors(Function fn) {
+	v8::Isolate* isolate = v8::Isolate::GetCurrent();
+	v8::TryCatch try_catch{isolate};
+	try {
+		return fn();
+	} catch (const detail::RuntimeErrorWithMessage& cc_error) {
+		throw std::logic_error("Invalid error thrown by RunWithAnnotatedErrors");
+	} catch (const RuntimeError& cc_error) {
+		try {
+			assert(try_catch.HasCaught());
+			v8::Local<v8::Context> context = isolate->GetCurrentContext();
+			v8::Local<v8::Value> error = try_catch.Exception();
+			v8::Local<v8::Message> message = try_catch.Message();
+			assert(error->IsObject());
+			int linenum = Unmaybe(message->GetLineNumber(context));
+			int start_column = Unmaybe(message->GetStartColumn(context));
+			auto name = message->GetScriptResourceName();
+			std::string decorator =
+				(name->IsString() ?
+					HandleCast<std::string>(message->GetScriptResourceName()) : "<isolated-vm>") +
+				":" + std::to_string(linenum) +
+				":" + std::to_string(start_column + 1);
+			auto message_key = HandleCast<v8::Local<v8::String>>("message");
+			std::string message_str = HandleCast<std::string>(Unmaybe(error.As<v8::Object>()->Get(context, message_key)));
+			Unmaybe(error.As<v8::Object>()->Set(context, message_key, HandleCast<v8::Local<v8::String>>(message_str + " [" + decorator + "]")));
+			isolate->ThrowException(error);
+			throw RuntimeError();
+		} catch (const RuntimeError& cc_error) {
+			try_catch.ReThrow();
+			throw RuntimeError();
+		}
+	}
+}
+
+} // namespace ivm

package/dist/node_modules/isolated-vm/src/module/external_copy_handle.cc

@@ -0,0 +1,119 @@
+#include "external_copy_handle.h"
+#include "external_copy/external_copy.h"
+
+using namespace v8;
+using std::shared_ptr;
+using std::unique_ptr;
+
+namespace ivm {
+
+/**
+ * Transferable wrapper
+ */
+ExternalCopyHandle::ExternalCopyTransferable::ExternalCopyTransferable(std::shared_ptr<ExternalCopy> value) : value(std::move(value)) {}
+
+auto ExternalCopyHandle::ExternalCopyTransferable::TransferIn() -> Local<Value> {
+	return ClassHandle::NewInstance<ExternalCopyHandle>(value);
+}
+
+/**
+ * ExternalCopyHandle implementation
+ */
+ExternalCopyHandle::ExternalCopyHandle(shared_ptr<ExternalCopy> value) : value(std::move(value)), size{this->value->Size()} {
+	Isolate::GetCurrent()->AdjustAmountOfExternalAllocatedMemory(size);
+}
+
+ExternalCopyHandle::~ExternalCopyHandle() {
+	Isolate::GetCurrent()->AdjustAmountOfExternalAllocatedMemory(-size);
+}
+
+auto ExternalCopyHandle::Definition() -> Local<FunctionTemplate> {
+	return Inherit<TransferableHandle>(MakeClass(
+		"ExternalCopy", ConstructorFunction<decltype(&New), &New>{},
+		"totalExternalSize", StaticAccessor<decltype(&ExternalCopyHandle::TotalExternalSizeGetter), &ExternalCopyHandle::TotalExternalSizeGetter>{},
+		"copy", MemberFunction<decltype(&ExternalCopyHandle::Copy), &ExternalCopyHandle::Copy>{},
+		"copyInto", MemberFunction<decltype(&ExternalCopyHandle::CopyInto), &ExternalCopyHandle::CopyInto>{},
+		"release", MemberFunction<decltype(&ExternalCopyHandle::Release), &ExternalCopyHandle::Release>{}
+	));
+}
+
+auto ExternalCopyHandle::TransferOut() -> unique_ptr<Transferable> {
+	return std::make_unique<ExternalCopyTransferable>(value);
+}
+
+auto ExternalCopyHandle::New(Local<Value> value, MaybeLocal<Object> maybe_options) -> unique_ptr<ExternalCopyHandle> {
+	Local<Object> options;
+	bool transfer_out = false;
+	ArrayRange transfer_list;
+	if (maybe_options.ToLocal(&options)) {
+		transfer_out = ReadOption<bool>(options, StringTable::Get().transferOut, false);
+		transfer_list = ReadOption<ArrayRange>(options, StringTable::Get().transferList, {});
+	}
+	return std::make_unique<ExternalCopyHandle>(shared_ptr<ExternalCopy>(ExternalCopy::Copy(value, transfer_out, transfer_list)));
+}
+
+void ExternalCopyHandle::CheckDisposed() const {
+	if (!value) {
+		throw RuntimeGenericError("Copy has been released");
+	}
+}
+
+/**
+ * JS API functions
+ */
+auto ExternalCopyHandle::TotalExternalSizeGetter() -> Local<Value> {
+	return Number::New(Isolate::GetCurrent(), ExternalCopy::TotalExternalSize());
+}
+
+auto ExternalCopyHandle::Copy(MaybeLocal<Object> maybe_options) -> Local<Value> {
+	CheckDisposed();
+	bool release = ReadOption<bool>(maybe_options, StringTable::Get().release, false);
+	bool transfer_in = ReadOption<bool>(maybe_options, StringTable::Get().transferIn, false);
+	Local<Value> ret = value->CopyIntoCheckHeap(transfer_in);
+	if (release) {
+		Release();
+	}
+	return ret;
+}
+
+auto ExternalCopyHandle::CopyInto(MaybeLocal<Object> maybe_options) -> Local<Value> {
+	CheckDisposed();
+	bool release = ReadOption<bool>(maybe_options, StringTable::Get().release, false);
+	bool transfer_in = ReadOption<bool>(maybe_options, StringTable::Get().transferIn, false);
+	Local<Value> ret = ClassHandle::NewInstance<ExternalCopyIntoHandle>(value, transfer_in);
+	if (release) {
+		Release();
+	}
+	return ret;
+}
+
+auto ExternalCopyHandle::Release() -> Local<Value> {
+	CheckDisposed();
+	Isolate::GetCurrent()->AdjustAmountOfExternalAllocatedMemory(-std::exchange(size, 0));
+	value.reset();
+	return Undefined(Isolate::GetCurrent());
+}
+
+/**
+ * ExternalCopyIntoHandle implementation
+ */
+ExternalCopyIntoHandle::ExternalCopyIntoTransferable::ExternalCopyIntoTransferable(shared_ptr<ExternalCopy> value, bool transfer_in) : value(std::move(value)), transfer_in(transfer_in) {}
+
+auto ExternalCopyIntoHandle::ExternalCopyIntoTransferable::TransferIn() -> Local<Value> {
+	return value->CopyIntoCheckHeap(transfer_in);
+}
+
+ExternalCopyIntoHandle::ExternalCopyIntoHandle(shared_ptr<ExternalCopy> value, bool transfer_in) : value(std::move(value)), transfer_in(transfer_in) {}
+
+auto ExternalCopyIntoHandle::Definition() -> Local<FunctionTemplate> {
+	return Inherit<TransferableHandle>(MakeClass("ExternalCopyInto", nullptr));
+}
+
+auto ExternalCopyIntoHandle::TransferOut() -> unique_ptr<Transferable> {
+	if (!value) {
+		throw RuntimeGenericError("The return value of `copyInto()` should only be used once");
+	}
+	return std::make_unique<ExternalCopyIntoTransferable>(std::move(value), transfer_in);
+}
+
+} // namespace ivm

package/dist/node_modules/isolated-vm/src/module/external_copy_handle.h

@@ -0,0 +1,64 @@
+#pragma once
+#include <v8.h>
+#include "transferable.h"
+#include <memory>
+
+namespace ivm {
+
+class ExternalCopy;
+
+class ExternalCopyHandle final : public TransferableHandle {
+	public:
+		class ExternalCopyTransferable : public Transferable {
+			private:
+				std::shared_ptr<ExternalCopy> value;
+
+			public:
+				explicit ExternalCopyTransferable(std::shared_ptr<ExternalCopy> value);
+				auto TransferIn() -> v8::Local<v8::Value> final;
+		};
+
+		std::shared_ptr<ExternalCopy> value;
+
+		void CheckDisposed() const;
+
+		explicit ExternalCopyHandle(std::shared_ptr<ExternalCopy> value);
+		ExternalCopyHandle(const ExternalCopyHandle&) = delete;
+		auto operator= (const ExternalCopyHandle&) -> ExternalCopyHandle& = delete;
+		~ExternalCopyHandle() final;
+		static auto Definition() -> v8::Local<v8::FunctionTemplate>;
+		auto TransferOut() -> std::unique_ptr<Transferable> final;
+
+		static auto New(v8::Local<v8::Value> value, v8::MaybeLocal<v8::Object> maybe_options) -> std::unique_ptr<ExternalCopyHandle>;
+		static auto TotalExternalSizeGetter() -> v8::Local<v8::Value>;
+		auto Copy(v8::MaybeLocal<v8::Object> maybe_options) -> v8::Local<v8::Value>;
+		auto CopyInto(v8::MaybeLocal<v8::Object> maybe_options) -> v8::Local<v8::Value>;
+		auto Release() -> v8::Local<v8::Value>;
+		auto GetValue() const -> std::shared_ptr<ExternalCopy> { return value; }
+
+	private:
+		int size = 0;
+};
+
+class ExternalCopyIntoHandle : public TransferableHandle {
+	private:
+		class ExternalCopyIntoTransferable : public Transferable {
+			private:
+				std::shared_ptr<ExternalCopy> value;
+				bool transfer_in;
+
+			public:
+				explicit ExternalCopyIntoTransferable(std::shared_ptr<ExternalCopy> value, bool transfer_in);
+				auto TransferIn() -> v8::Local<v8::Value> final;
+		};
+
+		std::shared_ptr<ExternalCopy> value;
+		bool transfer_in;
+
+	public:
+		explicit ExternalCopyIntoHandle(std::shared_ptr<ExternalCopy> value, bool transfer_in);
+		static auto Definition() -> v8::Local<v8::FunctionTemplate>;
+		auto TransferOut() -> std::unique_ptr<Transferable> final;
+};
+
+} // namespace ivm