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

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

@@ -0,0 +1,142 @@
+#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);
+}
+
+auto LimitedAllocator::Reallocate(void* data, size_t old_length, size_t new_length) -> void* {
+	auto delta = static_cast<ssize_t>(new_length) - static_cast<ssize_t>(old_length);
+	if (delta > 0) {
+		if (!Check(delta)) {
+			return nullptr;
+		}
+	}
+	env.extra_allocated_memory += delta;
+	return ArrayBuffer::Allocator::Reallocate(data, old_length, new_length);
+}
+
+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

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

@@ -0,0 +1,334 @@
+#pragma once
+#include <v8.h>
+#include "environment.h"
+#include "functor_runners.h"
+#include "util.h"
+#include "generic/callbacks.h"
+#include "generic/extract_params.h"
+#include "generic/handle_cast.h"
+#include "generic/read_option.h"
+#include "v8-function-callback.h"
+
+#include <cassert>
+#include <cstddef>
+#include <type_traits>
+#include <stdexcept>
+
+namespace ivm {
+
+namespace detail {
+	struct ConstructorFunctionHolder : detail::FreeFunctionHolder {
+		using FreeFunctionHolder::FreeFunctionHolder;
+	};
+
+	template <class Signature>
+	struct ConstructorFunctionImpl;
+
+	template <class Type>
+	struct TemplateHolder {
+		static IsolateSpecific<v8::FunctionTemplate> specific;
+	};
+
+	template <class Type>
+	IsolateSpecific<v8::FunctionTemplate> TemplateHolder<Type>::specific;
+
+	template <class Type, class = void>
+	struct DontFreezePrototype : std::false_type{};
+
+	template <class Type>
+	struct DontFreezePrototype<Type, typename Type::DontFreezePrototype> : std::true_type {};
+
+	template <class Type, class = void>
+	struct DontFreezeInstance : std::false_type{};
+
+	template <class Type>
+	struct DontFreezeInstance<Type, typename Type::DontFreezeInstance> : std::true_type {};
+
+}
+
+/**
+ * Analogous to node::ObjectWrap but Isolate-aware. Also has a bunch of unnecessary template stuff.
+ */
+class ClassHandle {
+	template <class Signature>
+	friend struct detail::ConstructorFunctionImpl;
+	private:
+		v8::Persistent<v8::Value> handle;
+
+		/**
+		 * Utility methods to set up object prototype
+		 */
+		struct TemplateDefinition {
+			v8::Isolate* isolate;
+			v8::Local<v8::FunctionTemplate>& tmpl;
+			v8::Local<v8::ObjectTemplate>& proto;
+			v8::Local<v8::Signature>& sig;
+
+			// This add regular methods
+			template <typename... Args>
+			void Add(const char* name, detail::MemberFunctionHolder impl, Args... args) {
+				v8::Local<v8::String> name_handle = v8_symbol(name);
+				proto->Set(name_handle, v8::FunctionTemplate::New(isolate, impl.callback, {}, sig, impl.length));
+				Add(args...);
+			}
+
+			// This adds function templates to the prototype
+			template <typename... Args>
+			void Add(const char* name, v8::Local<v8::FunctionTemplate>& value, Args... args) {
+				v8::Local<v8::String> name_handle = v8_symbol(name);
+				proto->Set(name_handle, value);
+				Add(args...);
+			}
+
+			// This adds static functions on the object constructor
+			template <typename... Args>
+			void Add(const char* name, detail::FreeFunctionHolder impl, Args... args) {
+				v8::Local<v8::String> name_handle = v8_symbol(name);
+				tmpl->Set(name_handle, v8::FunctionTemplate::New(isolate, impl.callback, {}, v8::Local<v8::Signature>(), impl.length));
+				Add(args...);
+			}
+
+			// This adds accessors
+			template <typename... Args>
+			void Add(const char* name, detail::MemberAccessorHolder impl, Args... args) {
+				v8::Local<v8::String> name_handle = v8_symbol(name);
+				proto->SetAccessor(name_handle, impl.getter.callback, impl.setter.callback);
+				Add(args...);
+			}
+
+			// This adds static accessors
+			template <typename... Args>
+			void Add(const char* name, detail::StaticAccessorHolder impl, Args... args) {
+				v8::Local<v8::String> name_handle = v8_symbol(name);
+				v8::Local<v8::FunctionTemplate> setter;
+				if (impl.setter.callback != nullptr) {
+					setter = v8::FunctionTemplate::New(isolate, impl.setter.callback, name_handle);
+				}
+				tmpl->SetAccessorProperty(name_handle, v8::FunctionTemplate::New(isolate, impl.getter.callback, {}), setter);
+				Add(args...);
+			}
+
+			void Add() {} // NOLINT
+		};
+
+		/**
+		 * Convenience wrapper for the obtuse SetWeak function signature. When the callback is called
+		 * the handle will already be gone.
+		 */
+		template <typename P, void (*F)(P*)>
+		void SetWeak(P* param) {
+			auto& isolate = IsolateEnvironment::GetCurrent();
+			isolate.AddWeakCallback(&this->handle, (void(*)(void*))F, param);
+			handle.SetWeak(param, WeakCallback<P, F>, v8::WeakCallbackType::kParameter);
+		}
+		template <typename P, void (*F)(P*)>
+		static void WeakCallback(const v8::WeakCallbackInfo<P>& info) {
+			F(info.GetParameter());
+		}
+
+		/**
+		 * Invoked once JS loses all references to this object
+		 */
+		static void WeakCallback(void* param) {
+			auto& isolate = IsolateEnvironment::GetCurrent();
+			auto* that = reinterpret_cast<ClassHandle*>(param);
+			isolate.RemoveWeakCallback(&that->handle);
+			delete that; // NOLINT
+		}
+
+		/**
+		 * Transfer ownership of this C++ pointer to the v8 handle lifetime.
+		 */
+		static void Wrap(std::unique_ptr<ClassHandle> ptr, v8::Local<v8::Object> handle) {
+			handle->SetAlignedPointerInInternalField(0, ptr.get());
+			ptr->handle.Reset(v8::Isolate::GetCurrent(), handle);
+			ClassHandle* ptr_raw = ptr.release();
+			ptr_raw->SetWeak<void, WeakCallback>(ptr_raw);
+		}
+
+		/**
+		 * It just throws when you call it; used when `nullptr` is passed as constructor
+		 */
+		static void PrivateConstructor(const v8::FunctionCallbackInfo<v8::Value>& info) {
+			throw RuntimeTypeError(detail::CalleeName(info)+ " constructor is private");
+		}
+
+	protected:
+		/**
+		 * Sets up this object's FunctionTemplate inside the current isolate
+		 */
+		template <typename... Args>
+		static auto MakeClass(const char* class_name, detail::ConstructorFunctionHolder New, Args... args) -> v8::Local<v8::FunctionTemplate> {
+			v8::Isolate* isolate = v8::Isolate::GetCurrent();
+			v8::Local<v8::String> name_handle = v8_symbol(class_name);
+			v8::Local<v8::FunctionTemplate> tmpl = v8::FunctionTemplate::New(
+				isolate, New.callback == nullptr ? PrivateConstructor : New.callback,
+				name_handle, {}, New.length
+			);
+			tmpl->SetClassName(name_handle);
+
+			auto instance_tmpl = tmpl->InstanceTemplate();
+			instance_tmpl->SetImmutableProto();
+			instance_tmpl->SetInternalFieldCount(1);
+
+			auto proto = tmpl->PrototypeTemplate();
+			proto->SetImmutableProto();
+			v8::Local<v8::Signature> sig = v8::Signature::New(isolate, tmpl);
+			TemplateDefinition def{isolate, tmpl, proto, sig};
+			def.Add(args...);
+
+			return tmpl;
+		}
+
+		/**
+		 * Inherit from another class's FunctionTemplate
+		 */
+		template <typename T>
+		static auto Inherit(v8::Local<v8::FunctionTemplate> definition) -> v8::Local<v8::FunctionTemplate> {
+			v8::Local<v8::FunctionTemplate> parent = GetFunctionTemplate<T>();
+			definition->Inherit(parent);
+			return definition;
+		}
+
+	public:
+		ClassHandle() = default;
+		ClassHandle(const ClassHandle&) = delete;
+		auto operator= (const ClassHandle&) -> ClassHandle& = delete;
+		virtual ~ClassHandle() {
+			if (!handle.IsEmpty()) {
+				handle.ClearWeak();
+				handle.Reset();
+			}
+		}
+
+		/**
+		 * Returns instance of this class for this context.
+		 */
+		template <typename T>
+		static auto Init() -> v8::Local<v8::Function> {
+			return GetFunctionTemplate<T>()->GetFunction();
+		}
+
+		/**
+		 * Returns the FunctionTemplate for this isolate, generating it if needed.
+		 */
+		template <class Type>
+		static auto GetFunctionTemplate() -> v8::Local<v8::FunctionTemplate> {
+			return detail::TemplateHolder<Type>::specific.Deref([&]() {
+				return Type::Definition();
+			});
+		}
+
+		/**
+		 * Freeze the handle and prototype unless `DontFreezeInstance` is set on the class handle
+		 */
+		template <class Type>
+		static auto MaybeFreeze(v8::Local<v8::Object> handle) {
+			auto context = handle->GetIsolate()->GetCurrentContext();
+			if (!detail::DontFreezePrototype<Type>::value) {
+				handle->GetPrototype().As<v8::Object>()->SetIntegrityLevel(context, v8::IntegrityLevel::kFrozen);
+			}
+			if (!detail::DontFreezeInstance<Type>::value) {
+				handle->SetIntegrityLevel(context, v8::IntegrityLevel::kFrozen);
+			}
+		}
+
+		/**
+		 * Builds a new instance of T from scratch, used in factory functions.
+		 */
+		template <typename T, typename ...Args>
+		static auto NewInstance(Args&&... args) -> v8::Local<v8::Object> {
+			auto context = v8::Isolate::GetCurrent()->GetCurrentContext();
+			v8::Local<v8::Object> instance = Unmaybe(GetFunctionTemplate<T>()->InstanceTemplate()->NewInstance(context));
+			MaybeFreeze<T>(instance);
+			Wrap(std::make_unique<T>(std::forward<Args>(args)...), instance);
+			return instance;
+		}
+
+		/**
+		 * Pull out native pointer from v8 handle
+		 */
+		template <typename T>
+		static auto Unwrap(v8::Local<v8::Object> handle) -> T* {
+			assert(!handle.IsEmpty());
+			if (!ClassHandle::GetFunctionTemplate<T>()->HasInstance(handle)) {
+				return nullptr;
+			}
+			assert(handle->InternalFieldCount() > 0);
+			return dynamic_cast<T*>(static_cast<ClassHandle*>(handle->GetAlignedPointerFromInternalField(0)));
+		}
+
+		/**
+		 * Returns the JS value that this ClassHandle points to
+		 */
+		auto This() -> v8::Local<v8::Object> {
+			return Deref(handle).As<v8::Object>();
+		}
+};
+
+// Conversions from v8::Value -> Type&
+template <class Type>
+inline auto HandleCastImpl(v8::Local<v8::Value> value, const HandleCastArguments& /*arguments*/, HandleCastTag<Type&> /*tag*/) -> Type& {
+	if (!value->IsObject()) {
+		throw ParamIncorrect("an object");
+	}
+	v8::Local<v8::Object> handle = value.As<v8::Object>();
+	if (handle->InternalFieldCount() != 1) {
+		throw ParamIncorrect("something else");
+	}
+	auto* ptr = ClassHandle::Unwrap<Type>(handle);
+	if (ptr == nullptr) {
+		throw ParamIncorrect("something else");
+	} else {
+		return *ptr;
+	}
+}
+
+namespace detail {
+
+template <class Signature>
+struct ConstructorFunctionImpl;
+
+template <class Signature>
+struct ConstructorFunctionImpl<Signature*> : ConstructorFunctionImpl<Signature> {};
+
+template <class Return, class ...Args>
+struct ConstructorFunctionImpl<Return(Args...)> {
+	using Type = v8::Local<v8::Value>(*)(v8::Local<v8::Value> This, Args... args);
+
+	template <Return(*Function)(Args...)>
+	static inline auto Invoke(v8::Local<v8::Value> This, Args... args) -> v8::Local<v8::Value> {
+		auto instance = Function(args...);
+		if (instance) {
+			v8::Local<v8::Object> handle = This.As<v8::Object>();
+			ClassHandle::MaybeFreeze<typename decltype(instance)::element_type>(handle);
+			ClassHandle::Wrap(std::move(instance), handle);
+			return handle;
+		} else {
+			return Undefined(v8::Isolate::GetCurrent());
+		}
+	}
+};
+
+} // namespace detail
+
+template <class Signature, Signature Function>
+struct ConstructorFunction : detail::ConstructorFunctionHolder {
+	using ConstructorFunctionHolder::ConstructorFunctionHolder;
+	ConstructorFunction() : ConstructorFunctionHolder{
+		Entry,
+		std::tuple_size<typename detail::extract_arguments<Signature>::arguments>::value} {}
+
+	static void Entry(const v8::FunctionCallbackInfo<v8::Value>& info) {
+		detail::RunBarrier([&]() {
+			if (!info.IsConstructCall()) {
+				throw RuntimeTypeError(detail::CalleeName(info)+ " must be called with `new`");
+			}
+			ToCallback<-1, typename Impl::Type, &Impl::template Invoke<Function>>()(info);
+		});
+	}
+
+	using Impl = detail::ConstructorFunctionImpl<Signature>;
+};
+
+} // namespace ivm

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

@@ -0,0 +1,220 @@
+#include "cpu_profile_manager.h"
+#include "environment.h"
+#include <algorithm>
+#include <climits>
+#include <cmath>
+#include <cstdio>
+#include <cstring>
+#include <memory>
+#include <mutex>
+#include <thread>
+#include <vector>
+#include "isolate/strings.h"
+#include "v8-platform.h"
+#include "v8.h"
+
+using namespace v8;
+
+namespace ivm {
+
+/**
+ * CpuProfileManagerImpl
+ */
+IVMCpuProfile::IVMCpuProfile(const std::shared_ptr<v8::CpuProfile>& cpuProfile):
+	profile_thread(std::this_thread::get_id()),
+	start_time(cpuProfile->GetStartTime()),
+	end_time(cpuProfile->GetEndTime()),
+	samples_count(cpuProfile->GetSamplesCount()) {
+
+	samples.reserve(samples_count);
+	timestamps.reserve(samples_count);
+	for (int64_t i = 0; i < samples_count; i++) {
+		const int idx = static_cast<int>(i);
+		samples.push_back(cpuProfile->GetSample(idx)->GetNodeId());
+		timestamps.push_back(cpuProfile->GetSampleTimestamp(idx));
+	}
+
+	// handle nodes
+	FlatNodes(cpuProfile->GetTopDownRoot(), &profileNodes);
+}
+
+auto IVMCpuProfile::GetTidValue(Isolate *iso) -> Local<Value>{
+	const auto tid = std::hash<std::thread::id>{}(profile_thread);
+	return Number::New(iso, static_cast<double>(tid));
+}
+
+auto IVMCpuProfile::BuildCpuProfile(Isolate *iso) -> Local<Value> {
+	auto& strings = StringTable::Get();
+	auto context = iso->GetCurrentContext();
+	auto profileObject = Object::New(iso);
+
+	Unmaybe(profileObject->Set(context, strings.startTime, Number::New(iso, static_cast<double>(start_time))));
+	Unmaybe(profileObject->Set(context, strings.endTime, Number::New(iso, static_cast<double>(end_time))));
+
+	const Local<Array> samplesArr = Array::New(iso);
+	const Local<Array> timeDeltasArr = Array::New(iso);
+
+	for (int64_t i = 0; i < samples_count; i++) {
+		Unmaybe(samplesArr->Set(context, i, Number::New(iso, static_cast<double>(samples[i]))));
+		Unmaybe(timeDeltasArr->Set(context, i, Number::New(iso, static_cast<double>(timestamps[i] - start_time))));
+	}
+	Unmaybe(profileObject->Set(context, strings.samples, samplesArr));
+	Unmaybe(profileObject->Set(context, strings.timeDeltas, timeDeltasArr));
+
+	const Local<Array> nodeArr = Array::New(iso, static_cast<int>(profileNodes.size()));
+	Unmaybe(profileObject->Set(context, strings.nodes, nodeArr));
+
+	const size_t count = profileNodes.size();
+	for (size_t i = 0; i < count; i++) {
+		ProfileNode node = profileNodes[i];
+		Unmaybe(nodeArr->Set(context, i, node.ToJSObject(iso)));
+	}
+
+	return profileObject;
+}
+
+auto IVMCpuProfile::ToJSObject(Isolate *iso) -> Local<Value> {
+	auto& strings = StringTable::Get();
+	auto context = iso->GetCurrentContext();
+	auto result = Object::New(iso);
+
+	Unmaybe(result->Set(context, (v8::Local<v8::Value>)strings.threadId, GetTidValue(iso)));
+	Unmaybe(result->Set(context, strings.profile, BuildCpuProfile(iso)));
+
+	return result;
+}
+
+IVMCpuProfile::CallFrame::CallFrame(const v8::CpuProfileNode* node):
+	function_name(node->GetFunctionNameStr()),
+	url(node->GetScriptResourceNameStr()),
+	script_id(node->GetScriptId()),
+	line_number(node->GetLineNumber()),
+	column_number(node->GetColumnNumber()) {}
+
+
+auto IVMCpuProfile::CallFrame::ToJSObject(v8::Isolate *iso) -> Local<Value> {
+	auto& strings = StringTable::Get();
+	Local<Object> callFrame = Object::New(iso);
+	const Local<Context> context = iso->GetCurrentContext();
+	Unmaybe(callFrame->Set(context, strings.functionName, String::NewFromUtf8(iso, function_name).ToLocalChecked()));
+	Unmaybe(callFrame->Set(context, strings.url, String::NewFromUtf8(iso, url).ToLocalChecked()));
+	Unmaybe(callFrame->Set(context, strings.scriptId, Number::New(iso, script_id)));
+	Unmaybe(callFrame->Set(context, strings.lineNumber, Number::New(iso, line_number)));
+	Unmaybe(callFrame->Set(context, strings.columnNumber, Number::New(iso, column_number)));
+	return callFrame;
+}
+
+IVMCpuProfile::ProfileNode::ProfileNode(const v8::CpuProfileNode* node):
+	hit_count(node->GetHitCount()),
+	node_id(node->GetNodeId()),
+	bailout_reason(node->GetBailoutReason()),
+	call_frame(node) {
+		const int childrenCount = node->GetChildrenCount();
+		children.reserve(childrenCount);
+		for (int i = 0; i < childrenCount; i++) {
+			children.push_back(node->GetChild(i)->GetNodeId());
+		}
+	}
+
+auto IVMCpuProfile::ProfileNode::ToJSObject(Isolate *iso) -> Local<Value> {
+	auto& strings = StringTable::Get();
+	auto context = iso->GetCurrentContext();
+
+	Local<Object> nodeObj = Object::New(iso);
+
+	Unmaybe(nodeObj->Set(context, strings.hitCount, Number::New(iso, hit_count)));
+	Unmaybe(nodeObj->Set(context, strings.id, Number::New(iso, node_id)));
+
+	if (strlen(bailout_reason) > 0) {
+		Unmaybe(nodeObj->Set(context, strings.bailoutReason, String::NewFromUtf8(iso, bailout_reason).ToLocalChecked()));
+	}
+
+	const int children_count = static_cast<int>(children.size());
+	const Local<Array> childrenArr = Array::New(iso, children_count);
+	Unmaybe(nodeObj->Set(context, strings.children, childrenArr));
+
+	for (int j = 0; j < children_count; j++) {
+		Unmaybe(childrenArr->Set(context, j, Number::New(iso, static_cast<double>(children[j]))));
+	}
+
+	const Local<Value> callFrame = call_frame.ToJSObject(iso);
+	Unmaybe(nodeObj->Set(context, strings.callFrame, callFrame));
+
+	return nodeObj;
+}
+
+CpuProfileManager::CpuProfileManager() = default;
+
+void CpuProfileManager::StartProfiling(const char* title) {
+	const std::lock_guard<std::mutex> lock(mutex);
+	std::string str(title);
+	profile_titles.insert(str);
+}
+
+auto CpuProfileManager::StopProfiling(const char* title) -> std::vector<IVMCpuProfile> {
+	const std::lock_guard<std::mutex> lock(mutex);
+	const std::string str_title(title);
+
+	std::vector<IVMCpuProfile> currently_collected;
+
+	if (profile_begin_ptrs.find(str_title) == profile_begin_ptrs.end()) {
+		return currently_collected;
+	}
+
+	auto iter = profile_begin_ptrs[str_title];
+
+	// Iterate using an iterator
+	for (auto it = iter; it != profile_items.end(); ++it) {
+		currently_collected.push_back(*it);
+	}
+
+	// remove the titles
+	profile_titles.erase(str_title);
+	// remove the profile ptr from map
+	profile_begin_ptrs.erase(str_title);
+
+	// TODO clean up old profiles, extract private method
+	CleanProfiles();
+
+	return currently_collected;
+}
+
+auto CpuProfileManager::IsProfiling() -> bool {
+	return !profile_titles.empty();
+}
+
+auto CpuProfileManager::InjestCpuProfile(const std::shared_ptr<v8::CpuProfile>& cpuProfile) -> void {
+	const std::lock_guard<std::mutex> lock(mutex);
+	profile_items.emplace_back(cpuProfile);
+
+	for(const std::string &title : profile_titles) {
+		if (profile_begin_ptrs.find(title) == profile_begin_ptrs.end()) {
+			profile_begin_ptrs[title] = std::prev(profile_items.end());
+		}
+	}
+}
+
+void CpuProfileManager::CleanProfiles() {
+	if (profile_titles.empty()) {
+		profile_items.clear();
+		profile_begin_ptrs.clear();
+	}
+
+	int64_t min_start_time = INT_MAX;
+
+	for (const auto& profile_item: profile_begin_ptrs) {
+		if (profile_item.second->GetStartTime() < min_start_time) {
+			min_start_time = profile_item.second->GetStartTime();
+		}
+	}
+
+	for (auto it = profile_items.begin(); it != profile_items.end(); ) {
+		if (it->GetStartTime() < min_start_time) {
+			it = profile_items.erase(it);
+		} else {
+			++it;
+		}
+	}
+}
+
+}