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

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

@@ -1,509 +0,0 @@
-#include "external_copy.h"
-#include "error.h"
-#include "serializer.h"
-#include "./string.h"
-
-#include "isolate/allocator.h"
-#include "isolate/environment.h"
-#include "isolate/functor_runners.h"
-#include "isolate/util.h"
-#include "isolate/v8_version.h"
-
-#include <algorithm>
-#include <cstring>
-
-using namespace v8;
-
-namespace ivm {
-namespace {
-
-/**
- * This is used for Number (several C++ types), or Boolean.
- */
-template <class Type>
-struct ExternalCopyTemplateCtor {
-	template <class Native>
-	static auto New(Isolate* isolate, Native value) -> Local<Value> {
-		return Type::New(isolate, value);
-	}
-};
-
-template <>
-struct ExternalCopyTemplateCtor<Uint32> {
-	static auto New(Isolate* isolate, uint32_t value) -> Local<Value> {
-		return Uint32::NewFromUnsigned(isolate, value);
-	}
-};
-
-template <class Type, class Native>
-class ExternalCopyTemplate : public ExternalCopy {
-	public:
-		explicit ExternalCopyTemplate(Local<Value> value) :
-			ExternalCopy{sizeof(ExternalCopyTemplate)},
-			value{value.As<Type>()->Value()} {}
-
-		auto CopyInto(bool /*transfer_in*/ = false) -> Local<Value> final {
-			return ExternalCopyTemplateCtor<Type>::New(Isolate::GetCurrent(), value);
-		}
-
-	private:
-		const Native value;
-};
-
-/**
- * BigInt data
- */
-struct ExternalCopyBigInt : public ExternalCopy {
-	public:
-		explicit ExternalCopyBigInt(Local<BigInt> value) {
-			int word_count = value->WordCount();
-			words.resize(word_count);
-			value->ToWordsArray(&sign_bit, &word_count, words.data());
-		}
-
-		auto CopyInto(bool /*transfer_in*/ = false) -> Local<Value> final {
-			return Unmaybe(BigInt::NewFromWords(
-				Isolate::GetCurrent()->GetCurrentContext(), sign_bit, words.size(), words.data()));
-		}
-
-	private:
-		int sign_bit = 0;
-		std::vector<uint64_t> words;
-};
-
-/**
- * null and undefined
- */
-class ExternalCopyNull : public ExternalCopy {
-	public:
-		auto CopyInto(bool /*transfer_in*/ = false) -> Local<Value> final {
-			return Null(Isolate::GetCurrent());
-		}
-};
-
-class ExternalCopyUndefined : public ExternalCopy {
-	public:
-		auto CopyInto(bool /*transfer_in*/ = false) -> v8::Local<v8::Value> final {
-			return Undefined(Isolate::GetCurrent());
-		}
-};
-
-// Global size counter
-std::atomic<size_t> total_allocated_size {0};
-
-} // anonymous namespace
-
-/**
- * ExternalCopy implementation
- */
-ExternalCopy::ExternalCopy(int size) : size{size} {
-	total_allocated_size += size;
-}
-
-ExternalCopy::ExternalCopy(ExternalCopy&& that) noexcept : size{std::exchange(that.size, 0)} {}
-
-ExternalCopy::~ExternalCopy() {
-	total_allocated_size -= size;
-}
-
-auto ExternalCopy::operator= (ExternalCopy&& that) noexcept -> ExternalCopy& {
-	size = std::exchange(that.size, 0);
-	return *this;
-}
-
-auto ExternalCopy::Copy(Local<Value> value, bool transfer_out, ArrayRange transfer_list)
--> std::unique_ptr<ExternalCopy> {
-	std::unique_ptr<ExternalCopy> copy = CopyIfPrimitive(value);
-	if (copy) {
-		return copy;
-	} else if (value->IsArrayBuffer()) {
-		Local<ArrayBuffer> array_buffer = Local<ArrayBuffer>::Cast(value);
-		if (!transfer_out) {
-			transfer_out = std::find(transfer_list.begin(), transfer_list.end(), array_buffer) != transfer_list.end();
-		}
-		if (transfer_out) {
-			return ExternalCopyArrayBuffer::Transfer(array_buffer);
-		} else {
-			return std::make_unique<ExternalCopyArrayBuffer>(array_buffer);
-		}
-	} else if (value->IsSharedArrayBuffer()) {
-		return std::make_unique<ExternalCopySharedArrayBuffer>(value.As<SharedArrayBuffer>());
-	} else if (value->IsArrayBufferView()) {
-		Local<ArrayBufferView> view = value.As<ArrayBufferView>();
-		using ViewType = ExternalCopyArrayBufferView::ViewType;
-		ViewType type;
-		if (view->IsUint8Array()) {
-			type = ViewType::Uint8;
-		} else if (view->IsUint8ClampedArray()) {
-			type = ViewType::Uint8Clamped;
-		} else if (view->IsInt8Array()) {
-			type = ViewType::Int8;
-		} else if (view->IsUint16Array()) {
-			type = ViewType::Uint16;
-		} else if (view->IsInt16Array()) {
-			type = ViewType::Int16;
-		} else if (view->IsUint32Array()) {
-			type = ViewType::Uint32;
-		} else if (view->IsInt32Array()) {
-			type = ViewType::Int32;
-		} else if (view->IsFloat32Array()) {
-			type = ViewType::Float32;
-		} else if (view->IsFloat64Array()) {
-			type = ViewType::Float64;
-		} else if (view->IsBigInt64Array()) {
-			type = ViewType::BigInt64;
-		} else if (view->IsBigUint64Array()) {
-			type = ViewType::BigUint64;
-		} else if (view->IsDataView()) {
-			type = ViewType::DataView;
-		} else {
-			assert(false);
-		}
-
-		// Sometimes TypedArrays don't actually have a real buffer allocated for them. The call to
-		// `Buffer()` below will force v8 to attempt to create a buffer if it doesn't exist, and if
-		// there is an allocation failure it will crash the process.
-		if (!view->HasBuffer()) {
-			auto* allocator = IsolateEnvironment::GetCurrent().GetLimitedAllocator();
-			if (allocator != nullptr && !allocator->Check(view->ByteLength())) {
-				throw RuntimeRangeError("Array buffer allocation failed");
-			}
-		}
-
-		// `Buffer()` returns a Local<ArrayBuffer> but it may be a Local<SharedArrayBuffer>
-		Local<Object> tmp = view->Buffer();
-		if (tmp->IsArrayBuffer()) {
-			Local<ArrayBuffer> array_buffer = tmp.As<ArrayBuffer>();
-			if (!transfer_out) {
-				transfer_out = std::find(transfer_list.begin(), transfer_list.end(), array_buffer) != transfer_list.end();
-			}
-			// Grab byte_offset and byte_length before the transfer because "neutering" the array buffer will null these out
-			size_t byte_offset = view->ByteOffset();
-			size_t byte_length = view->ByteLength();
-			std::unique_ptr<ExternalCopyArrayBuffer> external_buffer;
-			if (transfer_out) {
-				external_buffer = ExternalCopyArrayBuffer::Transfer(array_buffer);
-			} else {
-				external_buffer = std::make_unique<ExternalCopyArrayBuffer>(array_buffer);
-			}
-			return std::make_unique<ExternalCopyArrayBufferView>(std::move(external_buffer), type, byte_offset, byte_length);
-		} else {
-			assert(tmp->IsSharedArrayBuffer());
-			Local<SharedArrayBuffer> array_buffer = tmp.As<SharedArrayBuffer>();
-			return std::make_unique<ExternalCopyArrayBufferView>(std::make_unique<ExternalCopySharedArrayBuffer>(array_buffer), type, view->ByteOffset(), view->ByteLength());
-		}
-	} else if (value->IsObject()) {
-		return std::make_unique<ExternalCopySerialized>(value.As<Object>(), transfer_list);
-	} else {
-		throw RuntimeTypeError("Unsupported type");
-	}
-}
-
-namespace {
-	auto CopyIfPrimitiveImpl(Local<Value> value) -> std::unique_ptr<ExternalCopy> {
-		if (value->IsString()) {
-			return std::make_unique<ExternalCopyString>(value.As<String>());
-		} else if (value->IsNumber()) {
-			if (value->IsUint32()) {
-				return std::make_unique<ExternalCopyTemplate<Uint32, uint32_t>>(value);
-			} else if (value->IsInt32()) {
-				return std::make_unique<ExternalCopyTemplate<Int32, int32_t>>(value);
-			} else {
-				// This handles Infinity, -Infinity, NaN
-				return std::make_unique<ExternalCopyTemplate<Number, double>>(value);
-			}
-		} else if (value->IsBigInt()) {
-			return std::make_unique<ExternalCopyBigInt>(value.As<BigInt>());
-		} else if (value->IsBoolean()) {
-			return std::make_unique<ExternalCopyTemplate<Boolean, bool>>(value);
-		} else if (value->IsNull()) {
-			return std::make_unique<ExternalCopyNull>();
-		} else if (value->IsUndefined()) {
-			return std::make_unique<ExternalCopyUndefined>();
-		}
-		return {};
-	}
-}
-
-auto ExternalCopy::CopyIfPrimitive(Local<Value> value) -> std::unique_ptr<ExternalCopy> {
-	if (!value->IsObject()) {
-		return CopyIfPrimitiveImpl(value);
-	}
-	return {};
-}
-
-auto ExternalCopy::CopyThrownValue(Local<Value> value) -> std::unique_ptr<ExternalCopy> {
-	if (value->IsObject()) {
-
-		// Detect which subclass of Error was thrown (no better way to do this??)
-		Isolate* isolate = Isolate::GetCurrent();
-		Local<Object> object = Local<Object>::Cast(value);
-		std::string name = *String::Utf8Value{isolate, object->GetConstructorName()};
-		auto error_type = ExternalCopyError::ErrorType::CustomError;
-		if (name == "Error") {
-			error_type = ExternalCopyError::ErrorType::Error;
-		} else if (name == "RangeError") {
-			error_type = ExternalCopyError::ErrorType::RangeError;
-		} else if (name == "ReferenceError") {
-			error_type = ExternalCopyError::ErrorType::ReferenceError;
-		} else if (name == "SyntaxError") {
-			error_type = ExternalCopyError::ErrorType::SyntaxError;
-		} else if (name == "TypeError") {
-			error_type = ExternalCopyError::ErrorType::TypeError;
-		}
-
-		// Get error properties
-		Local<Context> context = isolate->GetCurrentContext();
-		TryCatch try_catch{isolate};
-		auto get_property = [&](Local<Object> object, const char* key) {
-			try {
-				Local<Value> value = Unmaybe(object->Get(context, v8_string(key)));
-				if (!value->IsUndefined()) {
-					return ExternalCopyString{Unmaybe(value->ToString(context))};
-				}
-			} catch (const RuntimeError& cc_err) {
-				try_catch.Reset();
-			}
-			return ExternalCopyString{};
-		};
-		ExternalCopyString message_copy = get_property(object, "message");
-		ExternalCopyString stack_copy = get_property(object, "stack");
-
-		// Return external error copy if this looked like an error
-		if (error_type != ExternalCopyError::ErrorType::CustomError || message_copy || stack_copy) {
-			ExternalCopyString name_copy;
-			if (!message_copy) {
-				message_copy = ExternalCopyString{""};
-			}
-			if (error_type == ExternalCopyError::ErrorType::CustomError) {
-				name_copy = get_property(object, "name");
-			}
-			return std::make_unique<ExternalCopyError>(error_type, std::move(name_copy), std::move(message_copy), std::move(stack_copy));
-		}
-	}
-	auto primitive_value = CopyIfPrimitiveImpl(value);
-	if (primitive_value) {
-		return primitive_value;
-	}
-	return std::make_unique<ExternalCopyError>(
-		ExternalCopyError::ErrorType::Error,
-		"An object was thrown from supplied code within isolated-vm, but that object was not an instance of `Error`."
-	);
-}
-
-auto ExternalCopy::CopyIntoCheckHeap(bool transfer_in) -> Local<Value> {
-	IsolateEnvironment::HeapCheck heap_check{IsolateEnvironment::GetCurrent()};
-	auto value = CopyInto(transfer_in);
-	heap_check.Epilogue();
-	return value;
-}
-
-auto ExternalCopy::TotalExternalSize() -> int {
-	return total_allocated_size;
-}
-
-void ExternalCopy::UpdateSize(int size) {
-	total_allocated_size -= this->size - size;
-	this->size = size;
-}
-
-/**
- * ExternalCopyError implementation
- */
-ExternalCopyError::ExternalCopyError(
-	ErrorType error_type,
-	ExternalCopyString name,
-	ExternalCopyString message,
-	ExternalCopyString stack
-) :
-	error_type{error_type},
-	name{std::move(name)},
-	message{std::move(message)},
-	stack{std::move(stack)} {}
-
-ExternalCopyError::ExternalCopyError(ErrorType error_type, const char* message, const std::string& stack) :
-	ExternalCopy{sizeof(ExternalCopyError)},
-	error_type{error_type},
-	message{ExternalCopyString{message}},
-	stack{stack.empty() ? ExternalCopyString{} : ExternalCopyString{stack}} {}
-
-auto ExternalCopyError::CopyInto(bool /*transfer_in*/) -> Local<Value> {
-
-	// First make the exception w/ correct + message
-	Local<Context> context = Isolate::GetCurrent()->GetCurrentContext();
-	Local<String> message = Local<String>::Cast(this->message.CopyInto(false));
-	Local<Value> handle;
-	switch (error_type) {
-		default:
-			handle = Exception::Error(message);
-			if (name) {
-				Unmaybe(handle.As<Object>()->DefineOwnProperty(context, StringTable::Get().name, name.CopyInto(), PropertyAttribute::DontEnum));
-			}
-			break;
-		case ErrorType::RangeError:
-			handle = Exception::RangeError(message);
-			break;
-		case ErrorType::ReferenceError:
-			handle = Exception::ReferenceError(message);
-			break;
-		case ErrorType::SyntaxError:
-			handle = Exception::SyntaxError(message);
-			break;
-		case ErrorType::TypeError:
-			handle = Exception::TypeError(message);
-			break;
-	}
-
-	// Now add stack information
-	if (this->stack) {
-		Local<String> stack = Local<String>::Cast(this->stack.CopyInto(false));
-		Unmaybe(Local<Object>::Cast(handle)->Set(context, StringTable::Get().stack, stack));
-	}
-	return handle;
-}
-
-/**
- * ExternalCopyAnyBuffer implementation
- */
-namespace {
-	void Detach(Local<ArrayBuffer> handle) {
-		handle->Detach();
-	}
-	auto IsDetachable(Local<ArrayBuffer> handle) {
-		return handle->IsDetachable();
-	}
-} // anonymous namespace
-
-
-
-/**
- * ExternalCopyArrayBuffer implementation
- */
-ExternalCopyArrayBuffer::ExternalCopyArrayBuffer(const void* data, size_t length) :
-		ExternalCopyAnyBuffer{ArrayBuffer::NewBackingStore(
-			std::malloc(length), length,
-			[](void* data, size_t /*length*/, void* /*param*/) { std::free(data); },
-			nullptr)}
-{
-	std::memcpy((*backing_store.read())->Data(), data, length);
-}
-
-ExternalCopyArrayBuffer::ExternalCopyArrayBuffer(Local<ArrayBuffer> handle) :
-	ExternalCopyArrayBuffer{
-		handle->GetBackingStore()->Data(),
-		handle->ByteLength()
-	} {}
-
-auto ExternalCopyArrayBuffer::Transfer(Local<ArrayBuffer> handle) -> std::unique_ptr<ExternalCopyArrayBuffer> {
-	if (!IsDetachable(handle)) {
-		throw RuntimeGenericError("Array buffer is invalid");
-	}
-	auto backing_store = handle->GetBackingStore();
-	Detach(handle);
-	return std::make_unique<ExternalCopyArrayBuffer>(std::move(backing_store));
-}
-
-auto ExternalCopyArrayBuffer::CopyInto(bool transfer_in) -> Local<Value> {
-	if (transfer_in) {
-		auto backing_store = std::exchange(*this->backing_store.write(), {});
-		if (!backing_store) {
-			throw RuntimeGenericError("Array buffer is invalid");
-		}
-		UpdateSize(0);
-		size_t size = backing_store->ByteLength();
-		auto handle = ArrayBuffer::New(Isolate::GetCurrent(), std::move(backing_store));
-		auto* allocator = IsolateEnvironment::GetCurrent().GetLimitedAllocator();
-		if (allocator != nullptr) {
-			allocator->Track(handle, size);
-		}
-		return handle;
-	} else {
-		auto* allocator = IsolateEnvironment::GetCurrent().GetLimitedAllocator();
-		auto backing_store = *this->backing_store.read();
-		if (!backing_store) {
-			throw RuntimeGenericError("Array buffer is invalid");
-		}
-		auto size = backing_store->ByteLength();
-		if (allocator != nullptr && !allocator->Check(size)) {
-			// ArrayBuffer::New will crash the process if there is an allocation failure, so we check
-			// here.
-			throw RuntimeRangeError("Array buffer allocation failed");
-		}
-		auto handle = ArrayBuffer::New(Isolate::GetCurrent(), size);
-		auto* data = handle->GetBackingStore()->Data();
-		std::memcpy(data, backing_store->Data(), size);
-		return handle;
-	}
-}
-
-/**
- * ExternalCopySharedArrayBuffer implementation
- */
-ExternalCopySharedArrayBuffer::ExternalCopySharedArrayBuffer(Local<SharedArrayBuffer> handle) :
-	ExternalCopyAnyBuffer{handle->GetBackingStore()} {}
-
-auto ExternalCopySharedArrayBuffer::CopyInto(bool /*transfer_in*/) -> Local<Value> {
-	auto backing_store = *this->backing_store.read();
-	size_t size = backing_store->ByteLength();
-	auto handle = SharedArrayBuffer::New(Isolate::GetCurrent(), std::move(backing_store));
-	auto* allocator = IsolateEnvironment::GetCurrent().GetLimitedAllocator();
-	if (allocator != nullptr) {
-		allocator->Track(handle, size);
-	}
-	return handle;
-}
-
-/**
- * ExternalCopyArrayBufferView implementation
- */
-ExternalCopyArrayBufferView::ExternalCopyArrayBufferView(
-	std::unique_ptr<ExternalCopyAnyBuffer> buffer,
-	ViewType type, size_t byte_offset, size_t byte_length
-) :
-	ExternalCopy(sizeof(ExternalCopyArrayBufferView)),
-	buffer(std::move(buffer)),
-	type(type),
-	byte_offset(byte_offset), byte_length(byte_length) {}
-
-template <typename T>
-auto NewTypedArrayView(Local<T> buffer, ExternalCopyArrayBufferView::ViewType type, size_t byte_offset, size_t byte_length) -> Local<Value> {
-	switch (type) {
-		case ExternalCopyArrayBufferView::ViewType::Uint8:
-			return Uint8Array::New(buffer, byte_offset, byte_length >> 0);
-		case ExternalCopyArrayBufferView::ViewType::Uint8Clamped:
-			return Uint8ClampedArray::New(buffer, byte_offset, byte_length >> 0);
-		case ExternalCopyArrayBufferView::ViewType::Int8:
-			return Int8Array::New(buffer, byte_offset, byte_length >> 0);
-		case ExternalCopyArrayBufferView::ViewType::Uint16:
-			return Uint16Array::New(buffer, byte_offset, byte_length >> 1);
-		case ExternalCopyArrayBufferView::ViewType::Int16:
-			return Int16Array::New(buffer, byte_offset, byte_length >> 1);
-		case ExternalCopyArrayBufferView::ViewType::Uint32:
-			return Uint32Array::New(buffer, byte_offset, byte_length >> 2);
-		case ExternalCopyArrayBufferView::ViewType::Int32:
-			return Int32Array::New(buffer, byte_offset, byte_length >> 2);
-		case ExternalCopyArrayBufferView::ViewType::Float32:
-			return Float32Array::New(buffer, byte_offset, byte_length >> 2);
-		case ExternalCopyArrayBufferView::ViewType::Float64:
-			return Float64Array::New(buffer, byte_offset, byte_length >> 3);
-		case ExternalCopyArrayBufferView::ViewType::BigInt64:
-			return BigInt64Array::New(buffer, byte_offset, byte_length >> 3);
-		case ExternalCopyArrayBufferView::ViewType::BigUint64:
-			return BigUint64Array::New(buffer, byte_offset, byte_length >> 3);
-		case ExternalCopyArrayBufferView::ViewType::DataView:
-			return DataView::New(buffer, byte_offset, byte_length);
-		default:
-			throw std::exception();
-	}
-}
-
-auto ExternalCopyArrayBufferView::CopyInto(bool transfer_in) -> Local<Value> {
-	Local<Value> buffer = this->buffer->CopyInto(transfer_in);
-	if (buffer->IsArrayBuffer()) {
-		return NewTypedArrayView(buffer.As<ArrayBuffer>(), type, byte_offset, byte_length);
-	} else {
-		return NewTypedArrayView(buffer.As<SharedArrayBuffer>(), type, byte_offset, byte_length);
-	}
-}
-
-} // namespace ivm

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

@@ -1,117 +0,0 @@
-#pragma once
-#include <v8.h>
-#include <atomic>
-#include <cstdint>
-#include <cstdlib>
-#include <memory>
-#include <vector>
-
-#include "isolate/generic/array.h"
-#include "isolate/allocator.h"
-#include "isolate/transferable.h"
-#include "isolate/util.h"
-#include "lib/lockable.h"
-
-namespace ivm {
-
-using handle_vector_t = std::vector<v8::Local<v8::Value>>;
-using transferable_vector_t = std::vector<std::unique_ptr<Transferable>>;
-using array_buffer_vector_t = std::vector<std::unique_ptr<class ExternalCopyArrayBuffer>>;
-using shared_buffer_vector_t = std::vector<std::unique_ptr<class ExternalCopySharedArrayBuffer>>;
-
-class ExternalCopy : public Transferable {
-	public:
-		ExternalCopy() = default;
-		ExternalCopy(const ExternalCopy&) = delete;
-		auto operator= (const ExternalCopy&) = delete;
-		~ExternalCopy() override;
-
-		/**
-		 * `Copy` may throw a v8 exception if JSON.stringify(value) throws
-		 */
-		static auto Copy(
-			v8::Local<v8::Value> value,
-			bool transfer_out = false,
-			ArrayRange transfer_list = {}
-		) -> std::unique_ptr<ExternalCopy>;
-
-		/**
-		 * If you give this a primitive v8::Value (except Symbol) it will return a ExternalCopy for you.
-		 * Otherwise it returns nullptr. This is used to automatically move simple values between
-		 * isolates where it is possible to do so perfectly.
-		 */
-		static auto CopyIfPrimitive(v8::Local<v8::Value> value) -> std::unique_ptr<ExternalCopy>;
-		static auto CopyThrownValue(v8::Local<v8::Value> value) -> std::unique_ptr<ExternalCopy>;
-
-		static auto TotalExternalSize() -> int;
-
-		auto CopyIntoCheckHeap(bool transfer_in = false) -> v8::Local<v8::Value>;
-		virtual auto CopyInto(bool transfer_in = false) -> v8::Local<v8::Value> = 0;
-		auto Size() const -> int { return size; }
-		auto TransferIn() -> v8::Local<v8::Value> final { return CopyIntoCheckHeap(); }
-
-	protected:
-		explicit ExternalCopy(int size);
-		ExternalCopy(ExternalCopy&& that) noexcept;
-		auto operator= (ExternalCopy&& that) noexcept -> ExternalCopy&;
-
-		void UpdateSize(int size);
-
-	private:
-		int size = 0;
-};
-
-/**
- * Base class for ArrayBuffer and SharedArrayBuffer
- */
-class ExternalCopyAnyBuffer : public ExternalCopy {
-	public:
-		explicit ExternalCopyAnyBuffer(std::shared_ptr<v8::BackingStore> backing_store) :
-			backing_store{std::move(backing_store)} {}
-		auto Acquire() const -> std::shared_ptr<v8::BackingStore> { return *backing_store.read(); }
-
-	protected:
-		lockable_t<std::shared_ptr<v8::BackingStore>> backing_store;
-};
-
-/**
- * ArrayBuffer instances
- */
-class ExternalCopyArrayBuffer : public ExternalCopyAnyBuffer {
-	public:
-		using ExternalCopyAnyBuffer::ExternalCopyAnyBuffer;
-		ExternalCopyArrayBuffer(const void* data, size_t length);
-		explicit ExternalCopyArrayBuffer(v8::Local<v8::ArrayBuffer> handle);
-
-		static auto Transfer(v8::Local<v8::ArrayBuffer> handle) -> std::unique_ptr<ExternalCopyArrayBuffer>;
-		auto CopyInto(bool transfer_in = false) -> v8::Local<v8::Value> final;
-};
-
-/**
- * SharedArrayBuffer instances
- */
-class ExternalCopySharedArrayBuffer : public ExternalCopyAnyBuffer {
-	public:
-		explicit ExternalCopySharedArrayBuffer(v8::Local<v8::SharedArrayBuffer> handle);
-
-		auto CopyInto(bool transfer_in = false) -> v8::Local<v8::Value> final;
-};
-
-/**
- * All types of TypedArray views w/ underlying buffer handle
- */
-class ExternalCopyArrayBufferView : public ExternalCopy {
-	public:
-		enum class ViewType { Uint8, Uint8Clamped, Int8, Uint16, Int16, Uint32, Int32, Float32, Float64, BigInt64, BigUint64, DataView };
-
-	private:
-		std::unique_ptr<ExternalCopyAnyBuffer> buffer;
-		ViewType type;
-		size_t byte_offset, byte_length;
-
-	public:
-		ExternalCopyArrayBufferView(std::unique_ptr<ExternalCopyAnyBuffer> buffer, ViewType type, size_t byte_offset, size_t byte_length);
-		auto CopyInto(bool transfer_in = false) -> v8::Local<v8::Value> final;
-};
-
-} // namespace ivm