@nocobase/plugin-workflow-javascript 2.1.0-beta.25 → 2.1.0-beta.27

package/dist/node_modules/isolated-vm/src/external_copy/serializer.cc

@@ -1,85 +0,0 @@
-#include "serializer.h"
-#include "isolate/allocator.h"
-
-using namespace v8;
-namespace ivm {
-
-/**
- * ExternalCopySerialized implementation
- */
-ExternalCopySerialized::ExternalCopySerialized(Local<Value> value, ArrayRange transfer_list) :
-BaseSerializer{[&](ValueSerializer& serializer, Local<Context> context) {
-	// Mark ArrayBuffers as transferred, but don't actually transfer yet otherwise it will invalidate
-	// array views before they are transferred
-	int ii = 0;
-	for (auto handle : transfer_list) {
-		if (handle->IsArrayBuffer()) {
-			serializer.TransferArrayBuffer(ii++, handle.As<ArrayBuffer>());
-		} else {
-			throw RuntimeTypeError("Non-ArrayBuffer passed in `transferList`");
-		}
-	}
-
-	// Serialize object and save
-	serializer.WriteHeader();
-	Unmaybe(serializer.WriteValue(context, value));
-}} {
-
-	// Transfer ArrayBuffers
-	for (auto handle : transfer_list) {
-		array_buffers.emplace_back(ExternalCopyArrayBuffer::Transfer(handle.As<ArrayBuffer>()));
-	}
-}
-
-auto ExternalCopySerialized::CopyInto(bool transfer_in) -> Local<Value> {
-	Local<Value> value;
-
-	Deserialize([&](ValueDeserializer& deserializer, Local<Context> context) {
-		// Transfer ArrayBuffers
-		for (unsigned ii = 0; ii < array_buffers.size(); ++ii) {
-			deserializer.TransferArrayBuffer(ii, array_buffers[ii]->CopyIntoCheckHeap(transfer_in).As<ArrayBuffer>());
-		}
-
-		// Deserialize object
-		Unmaybe(deserializer.ReadHeader(context));
-		return deserializer.ReadValue(context).ToLocal(&value);
-	});
-
-	return value;
-}
-
-/**
- * SerializedVector implementation
- */
-SerializedVector::SerializedVector(const v8::FunctionCallbackInfo<v8::Value>& info) :
-BaseSerializer([&](ValueSerializer& serializer, Local<Context> context) {
-	int length = info.Length();
-	serializer.WriteUint32(length);
-	for (int ii = 0; ii < length; ++ii) {
-		Unmaybe(serializer.WriteValue(context, info[ii]));
-	}
-}) {}
-
-auto SerializedVector::CopyIntoAsVector() -> std::vector<Local<Value>> {
-	std::vector<Local<Value>> result;
-	Deserialize([&](ValueDeserializer& deserializer, Local<Context> context) {
-		// Read length
-		uint32_t length;
-		Unmaybe(deserializer.ReadHeader(context));
-		if (!deserializer.ReadUint32(&length)) {
-			throw RuntimeGenericError("Invalid arguments payload");
-		}
-
-		// Read arguments
-		result.resize(length);
-		for (unsigned ii = 0; ii < length; ++ii) {
-			if (!deserializer.ReadValue(context).ToLocal(&result[ii])) {
-				return false;
-			}
-		}
-		return true;
-	});
-	return result;
-}
-
-} // namespace ivm

package/dist/node_modules/isolated-vm/src/external_copy/serializer.h

@@ -1,136 +0,0 @@
-#pragma once
-#include "external_copy.h"
-#include "isolate/environment.h"
-#include <deque>
-#include <memory>
-#include <vector>
-
-namespace ivm {
-namespace detail {
-
-class SerializationDelegateBase {
-	public:
-		SerializationDelegateBase(
-			std::deque<std::unique_ptr<Transferable>>& transferables,
-			std::deque<v8::CompiledWasmModule>& wasm_modules
-		) : transferables{transferables}, wasm_modules{wasm_modules} {}
-
-	protected:
-		std::deque<std::unique_ptr<Transferable>>& transferables;
-		std::deque<v8::CompiledWasmModule>& wasm_modules;
-};
-
-class SerializerDelegate : public SerializationDelegateBase, public v8::ValueSerializer::Delegate {
-	public:
-		using SerializationDelegateBase::SerializationDelegateBase;
-
-		void SetSerializer(v8::ValueSerializer* serializer) { this->serializer = serializer; }
-		void ThrowDataCloneError(v8::Local<v8::String> message) final;
-
-		auto GetSharedArrayBufferId(
-			v8::Isolate* isolate, v8::Local<v8::SharedArrayBuffer> shared_array_buffer) -> v8::Maybe<uint32_t> final;
-		auto GetWasmModuleTransferId(
-			v8::Isolate* isolate, v8::Local<v8::WasmModuleObject> module) -> v8::Maybe<uint32_t> final;
-		auto WriteHostObject(v8::Isolate* isolate, v8::Local<v8::Object> object) -> v8::Maybe<bool> final;
-
-	private:
-		v8::ValueSerializer* serializer = nullptr;
-};
-
-class DeserializerDelegate : public SerializationDelegateBase, public v8::ValueDeserializer::Delegate {
-	public:
-		using SerializationDelegateBase::SerializationDelegateBase;
-
-		void SetDeserializer(v8::ValueDeserializer* deserializer) { this->deserializer = deserializer; }
-
-		auto GetSharedArrayBufferFromId(
-			v8::Isolate* isolate, uint32_t clone_id) -> v8::MaybeLocal<v8::SharedArrayBuffer> final;
-		auto GetWasmModuleFromId(
-			v8::Isolate* isolate, uint32_t transfer_id) -> v8::MaybeLocal<v8::WasmModuleObject> final;
-		auto ReadHostObject(v8::Isolate* isolate) -> v8::MaybeLocal<v8::Object> final;
-
-	private:
-		v8::ValueDeserializer* deserializer = nullptr;
-};
-
-} // namespace detail
-
-/**
- * Abstract serializer which manages boilerplate and lifecycle management of the serialized blob
- */
-class BaseSerializer {
-	protected:
-		template <class Fn>
-		explicit BaseSerializer(Fn fn) {
-			// Initialize serializer and delegate
-			auto* isolate = v8::Isolate::GetCurrent();
-			auto context = isolate->GetCurrentContext();
-			detail::SerializerDelegate delegate{transferables, wasm_modules};
-			v8::ValueSerializer serializer{isolate, &delegate};
-			delegate.SetSerializer(&serializer);
-
-			// Run serialization
-			serializer.WriteHeader();
-			fn(serializer, context);
-
-			// Save to buffer
-			auto serialized_data = serializer.Release();
-			buffer = {serialized_data.first, std::free};
-			size = serialized_data.second;
-		}
-
-		template <class Fn>
-		auto Deserialize(Fn fn) {
-			// Initialize deserializer and delegate
-			auto* isolate = v8::Isolate::GetCurrent();
-			auto context = isolate->GetCurrentContext();
-			detail::DeserializerDelegate delegate{transferables, wasm_modules};
-			v8::ValueDeserializer deserializer{isolate, buffer.get(), size, &delegate};
-			delegate.SetDeserializer(&deserializer);
-
-			// Watch for allocation errors
-			auto* allocator = IsolateEnvironment::GetCurrent().GetLimitedAllocator();
-			int failures = allocator == nullptr ? 0 : allocator->GetFailureCount();
-			Unmaybe(deserializer.ReadHeader(context));
-
-			// Run implementation
-			if (!fn(deserializer, context)) {
-				// ValueDeserializer throws an unhelpful message when it fails to allocate an ArrayBuffer, so
-				// detect that case here and throw an appropriate message.
-				if (allocator != nullptr && allocator->GetFailureCount() != failures) {
-					throw RuntimeRangeError("Array buffer allocation failed");
-				} else {
-					throw RuntimeError();
-				}
-			}
-		}
-
-	private:
-		std::unique_ptr<uint8_t, decltype(std::free)*> buffer = {nullptr, std::free};
-		std::deque<std::unique_ptr<Transferable>> transferables;
-		std::deque<v8::CompiledWasmModule> wasm_modules;
-		size_t size;
-};
-
-/**
- * Single serialized value compatible with `Transferable`
- */
-class ExternalCopySerialized : public BaseSerializer, public ExternalCopy {
-	public:
-		ExternalCopySerialized(v8::Local<v8::Value> value, ArrayRange transfer_list);
-		auto CopyInto(bool transfer_in = false) -> v8::Local<v8::Value> final;
-
-	private:
-		std::vector<std::unique_ptr<ExternalCopyArrayBuffer>> array_buffers;
-};
-
-class SerializedVector : public BaseSerializer {
-	public:
-		explicit SerializedVector(const v8::FunctionCallbackInfo<v8::Value>& info);
-		auto CopyIntoAsVector() -> std::vector<v8::Local<v8::Value>>;
-
-	private:
-		std::vector<std::unique_ptr<ExternalCopyArrayBuffer>> array_buffers;
-};
-
-} // namespace ivm

package/dist/node_modules/isolated-vm/src/external_copy/serializer_nortti.cc

@@ -1,73 +0,0 @@
-#include "serializer.h"
-#include "isolate/functor_runners.h"
-#include "module/transferable.h"
-
-/**
- * This file is compiled *without* runtime type information, which matches the nodejs binary and
- * allows the serializer delegates to resolve correctly.
- */
-
-using namespace v8;
-
-namespace ivm::detail {
-
-void SerializerDelegate::ThrowDataCloneError(Local<String> message) {
-	Isolate::GetCurrent()->ThrowException(Exception::TypeError(message));
-}
-
-auto SerializerDelegate::GetSharedArrayBufferId(
-		Isolate* /*isolate*/, Local<SharedArrayBuffer> shared_array_buffer) -> Maybe<uint32_t> {
-	auto result = Nothing<uint32_t>();
-	detail::RunBarrier([&]() {
-		transferables.emplace_back(std::make_unique<ExternalCopySharedArrayBuffer>(shared_array_buffer));
-		result = Just<uint32_t>(transferables.size() - 1);
-	});
-	return result;
-}
-
-auto SerializerDelegate::GetWasmModuleTransferId(
-		Isolate* /*isolate*/, Local<WasmModuleObject> module) -> Maybe<uint32_t> {
-	auto result = Just<uint32_t>(wasm_modules.size());
-	wasm_modules.emplace_back(module->GetCompiledModule());
-	return result;
-}
-
-auto SerializerDelegate::WriteHostObject(Isolate* /*isolate*/, Local<Object> object) -> Maybe<bool> {
-	auto result = Nothing<bool>();
-	detail::RunBarrier([&]() {
-		serializer->WriteUint32(transferables.size());
-		transferables.emplace_back(TransferOut(object));
-		result = Just(true);
-	});
-	return result;
-}
-
-auto DeserializerDelegate::ReadHostObject(Isolate* /*isolate*/) -> MaybeLocal<Object> {
-	MaybeLocal<Object> result;
-	detail::RunBarrier([&]() {
-		uint32_t ii;
-		assert(deserializer->ReadUint32(&ii));
-		result = transferables[ii]->TransferIn().As<Object>();
-	});
-	return result;
-}
-
-auto DeserializerDelegate::GetSharedArrayBufferFromId(
-		Isolate* /*isolate*/, uint32_t clone_id) -> MaybeLocal<SharedArrayBuffer> {
-	MaybeLocal<SharedArrayBuffer> result;
-	detail::RunBarrier([&]() {
-		result = transferables[clone_id]->TransferIn().As<SharedArrayBuffer>();
-	});
-	return result;
-}
-
-auto DeserializerDelegate::GetWasmModuleFromId(
-		Isolate* isolate, uint32_t transfer_id) -> MaybeLocal<WasmModuleObject> {
-	MaybeLocal<WasmModuleObject> result;
-	detail::RunBarrier([&]() {
-		result = WasmModuleObject::FromCompiledModule(isolate, wasm_modules[transfer_id]);
-	});
-	return result;
-}
-
-} // namespace ivm::detail

package/dist/node_modules/isolated-vm/src/external_copy/string.cc

@@ -1,124 +0,0 @@
-#include "isolate/environment.h"
-#include "./string.h"
-#include <cstring>
-
-using namespace v8;
-
-namespace ivm {
-namespace {
-
-/**
- * Helper classes passed to v8 so we can reuse the same externally allocated memory for strings
- * between different isolates
- */
-class ExternalString final : public v8::String::ExternalStringResource {
-	public:
-		explicit ExternalString(std::shared_ptr<std::vector<char>> value) : value{std::move(value)} {
-			IsolateEnvironment::GetCurrent().AdjustExtraAllocatedMemory(this->value->size());
-		}
-
-		ExternalString(const ExternalString&) = delete;
-
-		~ExternalString() final {
-			auto* environment = Executor::GetCurrentEnvironment();
-			if (environment != nullptr) {
-				environment->AdjustExtraAllocatedMemory(-static_cast<int>(this->value->size()));
-			}
-		}
-
-		auto operator= (const ExternalString&) = delete;
-
-		auto data() const -> const uint16_t* final {
-			return reinterpret_cast<uint16_t*>(value->data());
-		}
-
-		auto length() const -> size_t final {
-			return value->size() >> 1;
-		}
-
-	private:
-		std::shared_ptr<std::vector<char>> value;
-};
-
-class ExternalStringOneByte final : public v8::String::ExternalOneByteStringResource {
-	public:
-		explicit ExternalStringOneByte(std::shared_ptr<std::vector<char>> value) : value{std::move(value)} {
-			IsolateEnvironment::GetCurrent().AdjustExtraAllocatedMemory(this->value->size());
-		}
-
-		ExternalStringOneByte(const ExternalStringOneByte&) = delete;
-
-		~ExternalStringOneByte() final {
-			auto* environment = Executor::GetCurrentEnvironment();
-			if (environment != nullptr) {
-				environment->AdjustExtraAllocatedMemory(-static_cast<int>(this->value->size()));
-			}
-		}
-
-		auto operator= (const ExternalStringOneByte&) = delete;
-
-		auto data() const -> const char* final {
-			return value->data();
-		}
-
-		auto length() const -> size_t final {
-			return value->size();
-		}
-
-	private:
-		std::shared_ptr<std::vector<char>> value;
-};
-
-} // anonymous namespace
-
-/**
- * ExternalCopyString implementation
- */
-ExternalCopyString::ExternalCopyString(Local<String> string) :
-		ExternalCopy{static_cast<int>((string->Length() << (string->IsOneByte() ? 0 : 1)) + sizeof(ExternalCopyString))} {
-	if (string->IsOneByte()) {
-		one_byte = true;
-		value = std::make_shared<std::vector<char>>(string->Length());
-		string->WriteOneByte(
-			Isolate::GetCurrent(),
-			reinterpret_cast<uint8_t*>(value->data()), 0, -1, String::WriteOptions::NO_NULL_TERMINATION
-		);
-	} else {
-		one_byte = false;
-		value = std::make_shared<std::vector<char>>(string->Length() << 1);
-		string->Write(
-			Isolate::GetCurrent(),
-			reinterpret_cast<uint16_t*>(value->data()), 0, -1, String::WriteOptions::NO_NULL_TERMINATION
-		);
-	}
-}
-
-ExternalCopyString::ExternalCopyString(const char* string) :
-	value{std::make_shared<std::vector<char>>(string, string + strlen(string))}, one_byte{true} {}
-
-ExternalCopyString::ExternalCopyString(const std::string& string) :
-	value{std::make_shared<std::vector<char>>(string.begin(), string.end())}, one_byte{true} {}
-
-auto ExternalCopyString::CopyInto(bool /*transfer_in*/) -> Local<Value> {
-	if (value->size() < 1024) {
-		// Strings under 1kb will be internal v8 strings. I didn't experiment with this at all, but it
-		// seems self-evident that there's some byte length under which it doesn't make sense to create
-		// an external string so I picked 1kb.
-		if (one_byte) {
-			return Unmaybe(String::NewFromOneByte(Isolate::GetCurrent(),
-				reinterpret_cast<uint8_t*>(value->data()), NewStringType::kNormal, value->size()));
-		} else {
-			return Unmaybe(String::NewFromTwoByte(Isolate::GetCurrent(),
-				reinterpret_cast<uint16_t*>(value->data()), NewStringType::kNormal, value->size() >> 1));
-		}
-	} else {
-		// External strings can save memory and/or copies
-		if (one_byte) {
-			return Unmaybe(String::NewExternalOneByte(Isolate::GetCurrent(), new ExternalStringOneByte(value)));
-		} else {
-			return Unmaybe(String::NewExternalTwoByte(Isolate::GetCurrent(), new ExternalString(value)));
-		}
-	}
-}
-
-} // namespace ivm

package/dist/node_modules/isolated-vm/src/external_copy/string.h

@@ -1,28 +0,0 @@
-#pragma once
-#include "external_copy.h"
-#include <memory>
-#include <vector>
-
-namespace ivm {
-
-class ExternalCopyString final : public ExternalCopy {
-	public:
-		ExternalCopyString() = default;
-		explicit ExternalCopyString(v8::Local<v8::String> string);
-		explicit ExternalCopyString(const char* string);
-		explicit ExternalCopyString(const std::string& string);
-		ExternalCopyString(const ExternalCopyString&) = delete;
-		ExternalCopyString(ExternalCopyString&& that) = default;
-		~ExternalCopyString() final = default;
-		auto operator= (const ExternalCopyString&) -> ExternalCopyString& = delete;
-		auto operator= (ExternalCopyString&& that) noexcept -> ExternalCopyString& = default;
-
-		explicit operator bool() const { return static_cast<bool>(value); }
-		auto CopyInto(bool transfer_in = false) -> v8::Local<v8::Value> final;
-
-	private:
-		std::shared_ptr<std::vector<char>> value;
-		bool one_byte = false;
-};
-
-} // namespace ivm

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

@@ -1,30 +0,0 @@
-#pragma once
-#include <v8.h>
-#include <memory>
-#include "v8_version.h"
-
-namespace ivm {
-
-class LimitedAllocator : public v8::ArrayBuffer::Allocator {
-	private:
-		class IsolateEnvironment& env;
-		size_t limit;
-		size_t v8_heap;
-		size_t next_check;
-		int failures = 0;
-
-	public:
-		auto Check(size_t length) -> bool;
-		explicit LimitedAllocator(class IsolateEnvironment& env, size_t limit);
-		auto Allocate(size_t length) -> void* final;
-		auto AllocateUninitialized(size_t length) -> void* final;
-		void Free(void* data, size_t length) final;
-
-		// This is used by ExternalCopy when an ArrayBuffer is transferred. The memory is not freed but
-		// we should no longer count it against the isolate
-		void AdjustAllocatedSize(ptrdiff_t length);
-		auto GetFailureCount() const -> int;
-		void Track(v8::Local<v8::Object> handle, size_t size);
-};
-
-} // namespace ivm

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

@@ -1,131 +0,0 @@
-#include "allocator.h"
-#include "environment.h"
-#include <cstdlib>
-
-using namespace v8;
-
-namespace ivm {
-namespace {
-
-class ExternalMemoryHandle {
-	public:
-		ExternalMemoryHandle(Local<Object> local_handle, size_t size) :
-				handle{Isolate::GetCurrent(), local_handle}, size{size} {
-			handle.SetWeak(reinterpret_cast<void*>(this), &WeakCallbackV8, WeakCallbackType::kParameter);
-			IsolateEnvironment::GetCurrent().AddWeakCallback(&handle, WeakCallback, this);
-		}
-
-		ExternalMemoryHandle(const ExternalMemoryHandle&) = delete;
-		auto operator=(const ExternalMemoryHandle&) = delete;
-
-		~ExternalMemoryHandle() {
-			auto* allocator = IsolateEnvironment::GetCurrent().GetLimitedAllocator();
-			if (allocator != nullptr) {
-				allocator->AdjustAllocatedSize(-static_cast<ptrdiff_t>(size));
-			}
-		};
-
-	private:
-		static void WeakCallbackV8(const WeakCallbackInfo<void>& info) {
-			WeakCallback(info.GetParameter());
-		}
-
-		static void WeakCallback(void* param) {
-			auto* that = reinterpret_cast<ExternalMemoryHandle*>(param);
-			IsolateEnvironment::GetCurrent().RemoveWeakCallback(&that->handle);
-			that->handle.Reset();
-			delete that;
-		}
-
-		v8::Persistent<v8::Value> handle;
-		size_t size;
-};
-
-} // anonymous namespace
-
-/**
- * ArrayBuffer::Allocator that enforces memory limits. The v8 documentation specifically says
- * that it's unsafe to call back into v8 from this class but I took a look at
- * GetHeapStatistics() and I think it'll be ok.
- */
-auto LimitedAllocator::Check(const size_t length) -> bool {
-	if (v8_heap + env.extra_allocated_memory + length > next_check) {
-		HeapStatistics heap_statistics;
-		Isolate* isolate = Isolate::GetCurrent();
-		isolate->GetHeapStatistics(&heap_statistics);
-		v8_heap = heap_statistics.used_heap_size();
-		if (v8_heap + env.extra_allocated_memory + length > limit + env.misc_memory_size) {
-			// This is might be dangerous but the tests pass soooo..
-			isolate->LowMemoryNotification();
-			isolate->GetHeapStatistics(&heap_statistics);
-			v8_heap = heap_statistics.used_heap_size();
-			if (v8_heap + env.extra_allocated_memory + length > limit + env.misc_memory_size) {
-				return false;
-			}
-		}
-		next_check = v8_heap + env.extra_allocated_memory + length + 1024 * 1024;
-	}
-	return v8_heap + env.extra_allocated_memory + length <= limit + env.misc_memory_size;
-}
-
-LimitedAllocator::LimitedAllocator(IsolateEnvironment& env, size_t limit) : env(env), limit(limit), v8_heap(1024 * 1024 * 4), next_check(1024 * 1024) {}
-
-auto LimitedAllocator::Allocate(size_t length) -> void* {
-	if (Check(length)) {
-		env.extra_allocated_memory += length;
-		return std::calloc(length, 1);
-	} else {
-		++failures;
-		if (length <= 64) { // kMinAddedElementsCapacity * sizeof(uint32_t)
-			// When a tiny TypedArray is created v8 will avoid calling the allocator and instead just use
-			// the internal heap. This is all fine until someone wants a pointer to the underlying buffer,
-			// in that case v8 will "materialize" an ArrayBuffer which does invoke this allocator. If the
-			// allocator refuses to return a valid pointer it will result in a hard crash so we have no
-			// choice but to let this allocation succeed. Luckily the amount of memory allocated is tiny
-			// and will soon be freed because at the same time we terminate the isolate.
-			env.extra_allocated_memory += length;
-			env.Terminate();
-			return std::calloc(length, 1);
-		} else {
-			// The places end up here are more graceful and will throw a RangeError
-			return nullptr;
-		}
-	}
-}
-
-auto LimitedAllocator::AllocateUninitialized(size_t length) -> void* {
-	if (Check(length)) {
-		env.extra_allocated_memory += length;
-		return std::malloc(length);
-	} else {
-		++failures;
-		if (length <= 64) {
-			env.extra_allocated_memory += length;
-			env.Terminate();
-			return std::malloc(length);
-		} else {
-			return nullptr;
-		}
-	}
-}
-
-void LimitedAllocator::Free(void* data, size_t length) {
-	env.extra_allocated_memory -= length;
-	next_check -= length;
-	std::free(data);
-}
-
-void LimitedAllocator::AdjustAllocatedSize(ptrdiff_t length) {
-	env.extra_allocated_memory += length;
-}
-
-auto LimitedAllocator::GetFailureCount() const -> int {
-	return failures;
-}
-
-void LimitedAllocator::Track(Local<Object> handle, size_t size) {
-	new ExternalMemoryHandle{handle, size};
-	AdjustAllocatedSize(size);
-}
-
-} // namespace ivm