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

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

@@ -1,338 +0,0 @@
-#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);
-				v8::Local<v8::FunctionTemplate> setter;
-				if (impl.setter.callback != nullptr) {
-					setter = v8::FunctionTemplate::New(isolate, impl.setter.callback, name_handle);
-				}
-				proto->SetAccessorProperty(name_handle, v8::FunctionTemplate::New(isolate, impl.getter.callback, {}), setter);
-				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

@@ -1,220 +0,0 @@
-#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;
-		}
-	}
-}
-
-}

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

@@ -1,100 +0,0 @@
-#pragma once
-#include <ratio>
-#include <string>
-#include <thread>
-#include <v8.h>
-
-#include "executor.h"
-#include "v8-profiler.h"
-
-#include <mutex>
-#include <queue>
-#include <set>
-#include <unordered_map>
-#include <vector>
-#include <list>
-
-namespace ivm {
-
-class IVMCpuProfile {
-	public:
-		explicit IVMCpuProfile(const std::shared_ptr<v8::CpuProfile>& cpuProfile);
-		~IVMCpuProfile() = default;
-
-		class CallFrame {
-			public:
-				explicit CallFrame(const v8::CpuProfileNode* node);
-				~CallFrame() = default;
-
-				auto ToJSObject(v8::Isolate *iso) -> v8::Local<v8::Value>;
-			private:
-				const char* function_name;
-				const char* url;
-				int script_id;
-				int line_number;
-				int column_number;
-		};
-
-		class ProfileNode {
-			public:
-				explicit ProfileNode(const v8::CpuProfileNode* node);
-				~ProfileNode() = default;
-
-				auto ToJSObject(v8::Isolate *iso) -> v8::Local<v8::Value>;
-			private:
-				unsigned int hit_count;
-				unsigned int node_id;
-				const char* bailout_reason;
-				std::vector<unsigned int> children;
-				CallFrame call_frame;
-		};
-
-		auto GetStartTime() const -> int64_t { return start_time; }
-
-		auto ToJSObject(v8::Isolate *iso) -> v8::Local<v8::Value>;
-
-
-	private:
-		std::thread::id profile_thread;
-		int64_t start_time;
-		int64_t end_time;
-		int64_t samples_count;
-		std::vector<unsigned int> samples;
-		std::vector<int64_t> timestamps;
-		std::vector<ProfileNode> profileNodes;
-
-		auto GetTidValue(v8::Isolate *iso) -> v8::Local<v8::Value>;
-
-		auto BuildCpuProfile(v8::Isolate *iso) -> v8::Local<v8::Value>;
-
-		void FlatNodes(const v8::CpuProfileNode* node, std::vector<ProfileNode>* nodes) { // NOLINT(misc-no-recursion)
-			nodes->emplace_back(node);
-			const int childrenCount = node->GetChildrenCount();
-
-			for (int index = 0; index < childrenCount; ++index) {
-				FlatNodes(node->GetChild(index), nodes);
-			}
-		}
-
-};
-
-class CpuProfileManager {
-	public:
-		CpuProfileManager();
-		void StartProfiling(const char* title);
-		auto StopProfiling(const char* title) -> std::vector<IVMCpuProfile>;
-		auto IsProfiling() -> bool;
-		auto InjestCpuProfile(const std::shared_ptr<v8::CpuProfile>& cpuProfile) -> void;
-
-		CpuProfileManager(const CpuProfileManager&) = delete;
-		auto operator= (const CpuProfileManager) = delete;
-		~CpuProfileManager() = default;
-	private:
-		void CleanProfiles();
-
-		std::set<std::string> profile_titles{};
-		std::list<IVMCpuProfile> profile_items{};
-		std::unordered_map<std::string, std::list<IVMCpuProfile>::iterator> profile_begin_ptrs{};
-		std::mutex mutex;
-};
-}