@nocobase/plugin-workflow-javascript 2.1.0-beta.26 → 2.1.0-beta.29

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

@@ -1,241 +0,0 @@
-#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

@@ -1,35 +0,0 @@
-#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

@@ -1,108 +0,0 @@
-#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{
-			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

@@ -1,99 +0,0 @@
-#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

@@ -1,125 +0,0 @@
-#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);
-}
-
-static std::unique_ptr<ExternalCopyHandle> ExternalCopyHandle_New_Wrapper(
-	v8::Local<v8::Value> value, v8::MaybeLocal<v8::Object> options
-) {
-	return ExternalCopyHandle::New(value, options);
-}
-
-auto ExternalCopyHandle::Definition() -> Local<FunctionTemplate> {
-	return Inherit<TransferableHandle>(MakeClass(
-		"ExternalCopy", ConstructorFunction<decltype(&ExternalCopyHandle_New_Wrapper), &ExternalCopyHandle_New_Wrapper>{},
-		"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

@@ -1,64 +0,0 @@
-#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