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

package/dist/node_modules/isolated-vm/isolated-vm.js

@@ -0,0 +1 @@
+(function(){var e={290:function(e,r,_){e.exports=_(794).ivm},794:function(e,r,_){e.exports=require(_.ab+"out/isolated_vm.node")}};var r={};function __nccwpck_require__(_){var i=r[_];if(i!==undefined){return i.exports}var t=r[_]={exports:{}};var a=true;try{e[_](t,t.exports,__nccwpck_require__);a=false}finally{if(a)delete r[_]}return t.exports}if(typeof __nccwpck_require__!=="undefined")__nccwpck_require__.ab=__dirname+"/";var _=__nccwpck_require__(290);module.exports=_})();

package/dist/node_modules/isolated-vm/native-example/binding.gyp

@@ -0,0 +1,23 @@
+{
+	'targets': [
+		{
+			'target_name': 'isolated-native-example',
+			'cflags_cc!': [ '-fno-exceptions' ],
+			'xcode_settings': {
+				'GCC_ENABLE_CPP_EXCEPTIONS': 'YES',
+			},
+			'msvs_settings': {
+				'VCCLCompilerTool': {
+					'ExceptionHandling': '1',
+				},
+			},
+			'include_dirs': [
+				'<!(node -e "require(\'nan\')")',
+				'<!(node -e "require(\'isolated-vm/include\')")',
+			],
+			'sources': [
+				'example.cc',
+			],
+		},
+	],
+}

package/dist/node_modules/isolated-vm/native-example/example.cc

@@ -0,0 +1,61 @@
+// Example module w/ async function
+
+#include <nan.h> // You don't have to use nan, but it's supported
+#include <isolated_vm.h>
+
+#include <chrono>
+#include <thread>
+
+// `using namespace` is omitted to better show which interfaces exist where.
+
+// `Runnable` is used for async function calls. It is possible that `Run` will never actually be
+// called, in the case the isolate is disposed. You should make sure to cleanup in the destructor
+// instead of `Run`.
+struct TimeoutCallback : public isolated_vm::Runnable {
+	// `RemoteHandle` should be used instead of `v8::Persistent` or `nan::Persistent`
+	isolated_vm::RemoteHandle<v8::Context> context;
+	isolated_vm::RemoteHandle<v8::Function> fn;
+
+	TimeoutCallback(
+		isolated_vm::RemoteHandle<v8::Context> context,
+		isolated_vm::RemoteHandle<v8::Function> fn
+	) :
+		context(std::move(context)),
+		fn(std::move(fn)) {}
+
+	void Run() override {
+		// `v8::Locker` and `v8::HandleScope` are already set up and the isolate is entered. All that is
+		// left to do is enter a context.
+		v8::Context::Scope context_scope(*context);
+		v8::Local<v8::Function> local_fn = *fn;
+		v8::Local<v8::Value> argv[0];
+		Nan::Call(local_fn, v8::Local<v8::Object>::Cast(Nan::Undefined()), 0, argv);
+	}
+};
+
+NAN_METHOD(timeout) {
+	isolated_vm::IsolateHolder isolate_holder = isolated_vm::IsolateHolder::GetCurrent();
+	isolated_vm::RemoteHandle<v8::Context> context(v8::Isolate::GetCurrent()->GetCurrentContext());
+	isolated_vm::RemoteHandle<v8::Function> fn(v8::Local<v8::Function>::Cast(info[0]));
+
+	uint32_t ms = Nan::To<uint32_t>(info[1]).FromJust();
+	std::thread timeout_thread([=]() mutable {
+		// Note that in this closure it is not safe to call into v8! The only thing you can do is
+		// schedule a task.
+		std::this_thread::sleep_for(std::chrono::milliseconds(ms));
+		isolate_holder.ScheduleTask(std::make_unique<TimeoutCallback>(std::move(context), std::move(fn)));
+	});
+	timeout_thread.detach();
+
+	info.GetReturnValue().Set(Nan::Undefined());
+}
+
+ISOLATED_VM_MODULE void InitForContext(v8::Isolate* isolate, v8::Local<v8::Context> context, v8::Local<v8::Object> target) {
+	Nan::Set(target, Nan::New("timeout").ToLocalChecked(), Nan::GetFunction(Nan::New<v8::FunctionTemplate>(timeout)).ToLocalChecked());
+}
+
+NAN_MODULE_INIT(init) {
+	v8::Isolate* isolate = v8::Isolate::GetCurrent();
+	InitForContext(isolate, isolate->GetCurrentContext(), target);
+}
+NODE_MODULE(native, init);

package/dist/node_modules/isolated-vm/native-example/package.json

@@ -0,0 +1,13 @@
+{
+  "name": "native-example",
+  "version": "1.0.0",
+  "main": "build/Release/isolated-native-example",
+  "scripts": {
+    "install": "node-gyp rebuild --release"
+  },
+  "license": "ISC",
+  "gypfile": true,
+  "dependencies": {
+    "nan": "^2.10.0"
+  }
+}

package/dist/node_modules/isolated-vm/native-example/usage.js

@@ -0,0 +1,35 @@
+'use strict';
+const ivm = require('isolated-vm');
+
+// You *must* require the extension in nodejs first.
+require('.');
+
+// `NativeModule` constructor takes a full path to a native module. `require.resolve` handles that
+// for us, and finds the module path from `package.json`.
+const example = new ivm.NativeModule(require.resolve('.'));
+
+// Create an isolate like normal
+let isolate = new ivm.Isolate;
+let context = isolate.createContextSync();
+let global = context.global;
+
+// Now you can load this module into the isolate. `create` or `createSync` call `InitForContext` in
+// C++ which returns a reference to this module for a specific context. The return value is an
+// instance of `ivm.Reference` which is just the same object that you would get by doing
+// `require('native-example')` in plain nodejs. The compiled native module is also compatible with
+// plain nodejs as well.
+global.setSync('module', example.createSync(context).derefInto());
+
+// Create unsafe log function
+global.setSync('log', new ivm.Reference(function(...args) {
+	console.log(...args);
+}));
+
+// Now we can test the function
+let script = isolate.compileScriptSync(`module.timeout(function() {
+	log.apply(0, [ "Timeout triggered" ]);
+}, 1000);`);
+console.log("Before runSync");
+script.runSync(context);
+console.log("After runSync");
+// logs: 123

package/dist/node_modules/isolated-vm/package.json

@@ -0,0 +1 @@
+{"name":"isolated-vm","version":"5.0.4","description":"Access to multiple isolates","main":"isolated-vm.js","types":"isolated-vm.d.ts","engines":{"node":">=18.0.0"},"scripts":{"install":"prebuild-install || (node-gyp rebuild --release -j max && node-gyp clean)","rebuild":"node-gyp rebuild --release -j max","lint":"find src -name '*.cc' | xargs -n1 clang-tidy","test":"node test.js"},"dependencies":{"prebuild-install":"^7.1.2"},"devDependencies":{"isolated-vm":".","prebuild":"^13.0.1"},"binary":{"module_path":"out"},"repository":{"type":"git","url":"git+https://github.com/laverdet/isolated-vm.git"},"author":"https://github.com/laverdet/","license":"ISC","gypfile":true,"bugs":{"url":"https://github.com/laverdet/isolated-vm/issues"},"homepage":"https://github.com/laverdet/isolated-vm#readme","_lastModified":"2026-04-08T08:19:15.155Z"}

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

@@ -0,0 +1,33 @@
+#pragma once
+#include "external_copy.h"
+#include "./string.h"
+
+namespace ivm {
+
+/**
+ * Make a special case for errors so if someone throws then a similar error will come out the other
+ * side.
+ */
+class ExternalCopyError : public ExternalCopy {
+	friend class ExternalCopy;
+	public:
+		enum class ErrorType { Error, RangeError, ReferenceError, SyntaxError, TypeError, CustomError };
+
+		ExternalCopyError(
+			ErrorType error_type,
+			ExternalCopyString name,
+			ExternalCopyString message,
+			ExternalCopyString stack
+		);
+		ExternalCopyError(ErrorType error_type, const char* message, const std::string& stack = "");
+
+		auto CopyInto(bool transfer_in = false) -> v8::Local<v8::Value> final;
+
+	private:
+		ErrorType error_type;
+		ExternalCopyString name;
+		ExternalCopyString message;
+		ExternalCopyString stack;
+};
+
+} // namespace ivm

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

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