@nativescript/canvas 2.0.0-alpha.10 → 2.0.0-alpha.12

package/pods/Headers/inspector/src/base/template-utils.h

@@ -1,113 +0,0 @@
-// Copyright 2017 the V8 project authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef V8_BASE_TEMPLATE_UTILS_H_
-#define V8_BASE_TEMPLATE_UTILS_H_
-
-#include <array>
-#include <functional>
-#include <iosfwd>
-#include <type_traits>
-#include <utility>
-
-namespace v8 {
-namespace base {
-
-namespace detail {
-
-template <typename Function, std::size_t... Indexes>
-constexpr inline auto make_array_helper(Function f,
-                                        std::index_sequence<Indexes...>)
-    -> std::array<decltype(f(0)), sizeof...(Indexes)> {
-  return {{f(Indexes)...}};
-}
-
-}  // namespace detail
-
-// base::make_array: Create an array of fixed length, initialized by a function.
-// The content of the array is created by calling the function with 0 .. Size-1.
-// Example usage to create the array {0, 2, 4}:
-//   std::array<int, 3> arr = base::make_array<3>(
-//       [](std::size_t i) { return static_cast<int>(2 * i); });
-// The resulting array will be constexpr if the passed function is constexpr.
-template <std::size_t Size, class Function>
-constexpr auto make_array(Function f) {
-  return detail::make_array_helper(f, std::make_index_sequence<Size>{});
-}
-
-// Helper to determine how to pass values: Pass scalars and arrays by value,
-// others by const reference (even if it was a non-const ref before; this is
-// disallowed by the style guide anyway).
-// The default is to also remove array extends (int[5] -> int*), but this can be
-// disabled by setting {remove_array_extend} to false.
-template <typename T, bool remove_array_extend = true>
-struct pass_value_or_ref {
-  using noref_t = typename std::remove_reference<T>::type;
-  using decay_t = typename std::conditional<
-      std::is_array<noref_t>::value && !remove_array_extend, noref_t,
-      typename std::decay<noref_t>::type>::type;
-  using type = typename std::conditional<std::is_scalar<decay_t>::value ||
-                                             std::is_array<decay_t>::value,
-                                         decay_t, const decay_t&>::type;
-};
-
-// Uses expression SFINAE to detect whether using operator<< would work.
-template <typename T, typename TStream = std::ostream, typename = void>
-struct has_output_operator : std::false_type {};
-template <typename T, typename TStream>
-struct has_output_operator<
-    T, TStream, decltype(void(std::declval<TStream&>() << std::declval<T>()))>
-    : std::true_type {};
-
-// Fold all arguments from left to right with a given function.
-template <typename Func, typename T>
-constexpr auto fold(Func func, T&& t) {
-  return std::forward<T>(t);
-}
-
-template <typename Func, typename T1, typename T2, typename... Ts>
-constexpr auto fold(Func func, T1&& first, T2&& second, Ts&&... more) {
-  auto&& folded = func(std::forward<T1>(first), std::forward<T2>(second));
-  return fold(std::move(func), std::forward<decltype(folded)>(folded),
-              std::forward<Ts>(more)...);
-}
-
-// {is_same<Ts...>::value} is true if all Ts are the same, false otherwise.
-template <typename... Ts>
-struct is_same : public std::false_type {};
-template <>
-struct is_same<> : public std::true_type {};
-template <typename T>
-struct is_same<T> : public std::true_type {};
-template <typename T, typename... Ts>
-struct is_same<T, T, Ts...> : public is_same<T, Ts...> {};
-
-// Returns true, iff all values (implicitly converted to bool) are trueish.
-template <typename... Args>
-constexpr bool all(Args... rest) {
-  return fold(std::logical_and<>{}, true, rest...);
-}
-
-template <class... Ts>
-struct make_void {
-  using type = void;
-};
-// Corresponds to C++17's std::void_t.
-// Used for SFINAE based on type errors.
-template <class... Ts>
-using void_t = typename make_void<Ts...>::type;
-
-// Corresponds to C++17's std::conjunction
-template <class...>
-struct conjunction : std::true_type {};
-template <class B>
-struct conjunction<B> : B {};
-template <class B, class... Bn>
-struct conjunction<B, Bn...>
-    : std::conditional_t<bool(B::value), conjunction<Bn...>, B> {};
-
-}  // namespace base
-}  // namespace v8
-
-#endif  // V8_BASE_TEMPLATE_UTILS_H_

package/pods/Headers/inspector/src/base/v8-fallthrough.h

@@ -1,21 +0,0 @@
-// Copyright 2018 the V8 project authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef V8_BASE_V8_FALLTHROUGH_H_
-#define V8_BASE_V8_FALLTHROUGH_H_
-
-// When clang suggests inserting [[clang::fallthrough]], it first checks if
-// it knows of a macro expanding to it, and if so suggests inserting the
-// macro.  This means that this macro must be used only in code internal
-// to v8, so that v8's user code doesn't end up getting suggestions
-// for V8_FALLTHROUGH instead of the user-specific fallthrough macro.
-// So do not include this header in any of v8's public headers -- only
-// use it in src/, not in include/.
-#if defined(__clang__)
-#define V8_FALLTHROUGH [[clang::fallthrough]]
-#else
-#define V8_FALLTHROUGH
-#endif
-
-#endif  // V8_BASE_V8_FALLTHROUGH_H_

package/pods/Headers/inspector/src/common/checks.h

@@ -1,38 +0,0 @@
-// Copyright 2012 the V8 project authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef V8_COMMON_CHECKS_H_
-#define V8_COMMON_CHECKS_H_
-
-#include "include/v8-internal.h"
-#include "src/base/logging.h"
-#include "src/common/globals.h"
-
-namespace v8 {
-
-class Value;
-
-namespace internal {
-
-#ifdef ENABLE_SLOW_DCHECKS
-#define SLOW_DCHECK(condition) \
-  CHECK(!v8::internal::FLAG_enable_slow_asserts || (condition))
-#define SLOW_DCHECK_IMPLIES(lhs, rhs) SLOW_DCHECK(!(lhs) || (rhs))
-V8_EXPORT_PRIVATE extern bool FLAG_enable_slow_asserts;
-#else
-#define SLOW_DCHECK(condition) ((void)0)
-#define SLOW_DCHECK_IMPLIES(v1, v2) ((void)0)
-static const bool FLAG_enable_slow_asserts = false;
-#endif
-
-}  // namespace internal
-}  // namespace v8
-
-#define DCHECK_TAG_ALIGNED(address) \
-  DCHECK((address & ::v8::internal::kHeapObjectTagMask) == 0)
-
-#define DCHECK_SIZE_TAG_ALIGNED(size) \
-  DCHECK((size & ::v8::internal::kHeapObjectTagMask) == 0)
-
-#endif  // V8_COMMON_CHECKS_H_