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

package/pods/Headers/inspector/third_party/inspector_protocol/crdtp/protocol_core.h

@@ -1,406 +0,0 @@
-// Copyright 2020 The Chromium 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_CRDTP_PROTOCOL_CORE_H_
-#define V8_CRDTP_PROTOCOL_CORE_H_
-
-#include <sys/types.h>
-
-#include <memory>
-#include <string>
-#include <vector>
-
-#include "cbor.h"
-#include "maybe.h"
-#include "serializable.h"
-#include "span.h"
-#include "status.h"
-
-namespace v8_crdtp {
-
-class DeserializerState {
- public:
-  using Storage = std::shared_ptr<const std::vector<uint8_t>>;
-
-  // Creates a state from the raw bytes received from the peer.
-  explicit DeserializerState(std::vector<uint8_t> bytes);
-  // Creates the state from the part of another message.
-  DeserializerState(Storage storage, span<uint8_t> span);
-  DeserializerState(const DeserializerState& r) = delete;
-  DeserializerState(DeserializerState&& r) = default;
-
-  // Registers |error|, unless the tokenizer's status is already an error.
-  void RegisterError(Error error);
-  // Registers |name| as a segment of the field path.
-  void RegisterFieldPath(span<char> name);
-
-  // Produces an error message considering |tokenizer.Status()|,
-  // status_, and field_path_.
-  std::string ErrorMessage(span<char> message_name) const;
-  Status status() const;
-  const Storage& storage() const { return storage_; }
-  cbor::CBORTokenizer* tokenizer() { return &tokenizer_; }
-
- private:
-  const Storage storage_;
-  cbor::CBORTokenizer tokenizer_;
-  Status status_;
-  std::vector<span<char>> field_path_;
-};
-
-template <typename T, typename = void>
-struct ProtocolTypeTraits {};
-
-template <>
-struct ProtocolTypeTraits<bool> {
-  static bool Deserialize(DeserializerState* state, bool* value);
-  static void Serialize(bool value, std::vector<uint8_t>* bytes);
-};
-
-template <>
-struct ProtocolTypeTraits<int32_t> {
-  static bool Deserialize(DeserializerState* state, int* value);
-  static void Serialize(int value, std::vector<uint8_t>* bytes);
-};
-
-template <>
-struct ProtocolTypeTraits<double> {
-  static bool Deserialize(DeserializerState* state, double* value);
-  static void Serialize(double value, std::vector<uint8_t>* bytes);
-};
-
-class ContainerSerializer {
- public:
-  ContainerSerializer(std::vector<uint8_t>* bytes, uint8_t tag);
-
-  template <typename T>
-  void AddField(span<char> field_name, const T& value) {
-    cbor::EncodeString8(
-        span<uint8_t>(reinterpret_cast<const uint8_t*>(field_name.data()),
-                      field_name.size()),
-        bytes_);
-    ProtocolTypeTraits<T>::Serialize(value, bytes_);
-  }
-  template <typename T>
-  void AddField(span<char> field_name, const detail::ValueMaybe<T>& value) {
-    if (!value.isJust())
-      return;
-    AddField(field_name, value.fromJust());
-  }
-  template <typename T>
-  void AddField(span<char> field_name, const detail::PtrMaybe<T>& value) {
-    if (!value.isJust())
-      return;
-    AddField(field_name, *value.fromJust());
-  }
-
-  void EncodeStop();
-
- private:
-  std::vector<uint8_t>* const bytes_;
-  cbor::EnvelopeEncoder envelope_;
-};
-
-class ObjectSerializer {
- public:
-  ObjectSerializer();
-  ~ObjectSerializer();
-
-  template <typename T>
-  void AddField(span<char> name, const T& field) {
-    serializer_.AddField(name, field);
-  }
-  std::unique_ptr<Serializable> Finish();
-
- private:
-  std::vector<uint8_t> owned_bytes_;
-  ContainerSerializer serializer_;
-};
-
-class DeserializerDescriptor {
- public:
-  struct Field {
-    span<char> name;
-    bool is_optional;
-    bool (*deserializer)(DeserializerState* state, void* obj);
-  };
-
-  DeserializerDescriptor(const Field* fields, size_t field_count);
-
-  bool Deserialize(DeserializerState* state, void* obj) const;
-
- private:
-  bool DeserializeField(DeserializerState* state,
-                        span<char> name,
-                        int* seen_mandatory_fields,
-                        void* obj) const;
-
-  const Field* const fields_;
-  const size_t field_count_;
-  const int mandatory_field_mask_;
-};
-
-template <typename T>
-struct ProtocolTypeTraits<std::vector<T>> {
-  static bool Deserialize(DeserializerState* state, std::vector<T>* value) {
-    auto* tokenizer = state->tokenizer();
-    if (tokenizer->TokenTag() == cbor::CBORTokenTag::ENVELOPE)
-      tokenizer->EnterEnvelope();
-    if (tokenizer->TokenTag() != cbor::CBORTokenTag::ARRAY_START) {
-      state->RegisterError(Error::CBOR_ARRAY_START_EXPECTED);
-      return false;
-    }
-    assert(value->empty());
-    tokenizer->Next();
-    for (; tokenizer->TokenTag() != cbor::CBORTokenTag::STOP;
-         tokenizer->Next()) {
-      value->emplace_back();
-      if (!ProtocolTypeTraits<T>::Deserialize(state, &value->back()))
-        return false;
-    }
-    return true;
-  }
-
-  static void Serialize(const std::vector<T>& value,
-                        std::vector<uint8_t>* bytes) {
-    ContainerSerializer container_serializer(
-        bytes, cbor::EncodeIndefiniteLengthArrayStart());
-    for (const auto& item : value)
-      ProtocolTypeTraits<T>::Serialize(item, bytes);
-    container_serializer.EncodeStop();
-  }
-};
-
-template <typename T>
-struct ProtocolTypeTraits<std::unique_ptr<std::vector<T>>> {
-  static bool Deserialize(DeserializerState* state,
-                          std::unique_ptr<std::vector<T>>* value) {
-    auto res = std::make_unique<std::vector<T>>();
-    if (!ProtocolTypeTraits<std::vector<T>>::Deserialize(state, res.get()))
-      return false;
-    *value = std::move(res);
-    return true;
-  }
-  static void Serialize(const std::unique_ptr<std::vector<T>>& value,
-                        std::vector<uint8_t>* bytes) {
-    ProtocolTypeTraits<std::vector<T>>::Serialize(*value, bytes);
-  }
-};
-
-class DeferredMessage : public Serializable {
- public:
-  static std::unique_ptr<DeferredMessage> FromSerializable(
-      std::unique_ptr<Serializable> serializeable);
-  static std::unique_ptr<DeferredMessage> FromSpan(span<uint8_t> bytes);
-
-  ~DeferredMessage() override = default;
-  virtual DeserializerState MakeDeserializer() const = 0;
-
- protected:
-  DeferredMessage() = default;
-};
-
-template <>
-struct ProtocolTypeTraits<std::unique_ptr<DeferredMessage>> {
-  static bool Deserialize(DeserializerState* state,
-                          std::unique_ptr<DeferredMessage>* value);
-  static void Serialize(const std::unique_ptr<DeferredMessage>& value,
-                        std::vector<uint8_t>* bytes);
-};
-
-template <typename T>
-struct ProtocolTypeTraits<detail::ValueMaybe<T>> {
-  static bool Deserialize(DeserializerState* state,
-                          detail::ValueMaybe<T>* value) {
-    T res;
-    if (!ProtocolTypeTraits<T>::Deserialize(state, &res))
-      return false;
-    *value = std::move(res);
-    return true;
-  }
-
-  static void Serialize(const detail::ValueMaybe<T>& value,
-                        std::vector<uint8_t>* bytes) {
-    ProtocolTypeTraits<T>::Serialize(value.fromJust(), bytes);
-  }
-};
-
-template <typename T>
-struct ProtocolTypeTraits<detail::PtrMaybe<T>> {
-  static bool Deserialize(DeserializerState* state,
-                          detail::PtrMaybe<T>* value) {
-    std::unique_ptr<T> res;
-    if (!ProtocolTypeTraits<std::unique_ptr<T>>::Deserialize(state, &res))
-      return false;
-    *value = std::move(res);
-    return true;
-  }
-
-  static void Serialize(const detail::PtrMaybe<T>& value,
-                        std::vector<uint8_t>* bytes) {
-    ProtocolTypeTraits<T>::Serialize(*value.fromJust(), bytes);
-  }
-};
-
-template <typename T>
-class DeserializableProtocolObject {
- public:
-  static StatusOr<std::unique_ptr<T>> ReadFrom(
-      const DeferredMessage& deferred_message) {
-    auto state = deferred_message.MakeDeserializer();
-    if (auto res = Deserialize(&state))
-      return StatusOr<std::unique_ptr<T>>(std::move(res));
-    return StatusOr<std::unique_ptr<T>>(state.status());
-  }
-
-  static StatusOr<std::unique_ptr<T>> ReadFrom(std::vector<uint8_t> bytes) {
-    auto state = DeserializerState(std::move(bytes));
-    if (auto res = Deserialize(&state))
-      return StatusOr<std::unique_ptr<T>>(std::move(res));
-    return StatusOr<std::unique_ptr<T>>(state.status());
-  }
-
-  // Short-hand for legacy clients. This would swallow any errors, consider
-  // using ReadFrom.
-  static std::unique_ptr<T> FromBinary(const uint8_t* bytes, size_t size) {
-    std::unique_ptr<T> value(new T());
-    auto deserializer = DeferredMessage::FromSpan(span<uint8_t>(bytes, size))
-                            ->MakeDeserializer();
-    Deserialize(&deserializer, value.get());
-    return value;
-  }
-
-  static bool Deserialize(DeserializerState* state, T* value) {
-    return T::deserializer_descriptor().Deserialize(state, value);
-  }
-
- protected:
-  // This is for the sake of the macros used by derived classes thay may be in
-  // a different namespace;
-  using ProtocolType = T;
-  using DeserializerDescriptorType = DeserializerDescriptor;
-  template <typename U>
-  using DeserializableBase = DeserializableProtocolObject<U>;
-
-  DeserializableProtocolObject() = default;
-  ~DeserializableProtocolObject() = default;
-
- private:
-  friend struct ProtocolTypeTraits<std::unique_ptr<T>>;
-
-  static std::unique_ptr<T> Deserialize(DeserializerState* state) {
-    std::unique_ptr<T> value(new T());
-    if (Deserialize(state, value.get()))
-      return value;
-    return nullptr;
-  }
-};
-
-template <typename T>
-class ProtocolObject : public Serializable,
-                       public DeserializableProtocolObject<T> {
- public:
-  std::unique_ptr<T> Clone() const {
-    std::vector<uint8_t> serialized;
-    AppendSerialized(&serialized);
-    return T::ReadFrom(std::move(serialized)).value();
-  }
-  // TODO(caseq): compatibility only, remove.
-  std::unique_ptr<T> clone() const { return Clone(); }
-
- protected:
-  using ProtocolType = T;
-
-  ProtocolObject() = default;
-};
-
-template <typename T>
-struct ProtocolTypeTraits<
-    T,
-    typename std::enable_if<
-        std::is_base_of<ProtocolObject<T>, T>::value>::type> {
-  static bool Deserialize(DeserializerState* state, T* value) {
-    return T::Deserialize(state, value);
-  }
-
-  static void Serialize(const T& value, std::vector<uint8_t>* bytes) {
-    value.AppendSerialized(bytes);
-  }
-};
-
-template <typename T>
-struct ProtocolTypeTraits<
-    std::unique_ptr<T>,
-    typename std::enable_if<
-        std::is_base_of<ProtocolObject<T>, T>::value>::type> {
-  static bool Deserialize(DeserializerState* state, std::unique_ptr<T>* value) {
-    std::unique_ptr<T> res = T::Deserialize(state);
-    if (!res)
-      return false;
-    *value = std::move(res);
-    return true;
-  }
-
-  static void Serialize(const std::unique_ptr<T>& value,
-                        std::vector<uint8_t>* bytes) {
-    ProtocolTypeTraits<T>::Serialize(*value, bytes);
-  }
-};
-
-#define DECLARE_DESERIALIZATION_SUPPORT()  \
-  friend DeserializableBase<ProtocolType>; \
-  static const DeserializerDescriptorType& deserializer_descriptor()
-
-#define DECLARE_SERIALIZATION_SUPPORT()                              \
- public:                                                             \
-  void AppendSerialized(std::vector<uint8_t>* bytes) const override; \
-                                                                     \
- private:                                                            \
-  friend DeserializableBase<ProtocolType>;                           \
-  static const DeserializerDescriptorType& deserializer_descriptor()
-
-#define V8_CRDTP_DESERIALIZE_FILED_IMPL(name, field, is_optional)  \
-  {                                                                \
-    MakeSpan(name), is_optional,                                   \
-        [](DeserializerState* __state, void* __obj) -> bool {      \
-          return ProtocolTypeTraits<decltype(field)>::Deserialize( \
-              __state, &static_cast<ProtocolType*>(__obj)->field); \
-        }                                                          \
-  }
-
-// clang-format off
-#define V8_CRDTP_BEGIN_DESERIALIZER(type)                                      \
-  const type::DeserializerDescriptorType& type::deserializer_descriptor() { \
-    using namespace v8_crdtp;                                                  \
-    static const DeserializerDescriptorType::Field fields[] = {
-
-#define V8_CRDTP_END_DESERIALIZER()                    \
-    };                                              \
-    static const DeserializerDescriptorType s_desc( \
-        fields, sizeof fields / sizeof fields[0]);  \
-    return s_desc;                                  \
-  }
-
-#define V8_CRDTP_DESERIALIZE_FIELD(name, field) \
-  V8_CRDTP_DESERIALIZE_FILED_IMPL(name, field, false)
-#define V8_CRDTP_DESERIALIZE_FIELD_OPT(name, field) \
-  V8_CRDTP_DESERIALIZE_FILED_IMPL(name, field, true)
-
-#define V8_CRDTP_BEGIN_SERIALIZER(type)                               \
-  void type::AppendSerialized(std::vector<uint8_t>* bytes) const { \
-    using namespace v8_crdtp;                                         \
-    ContainerSerializer __serializer(bytes,                        \
-                                     cbor::EncodeIndefiniteLengthMapStart());
-
-#define V8_CRDTP_SERIALIZE_FIELD(name, field) \
-    __serializer.AddField(MakeSpan(name), field)
-
-#define V8_CRDTP_END_SERIALIZER() \
-    __serializer.EncodeStop();   \
-  } class __cddtp_dummy_name
-// clang-format on
-
-}  // namespace v8_crdtp
-
-#endif  // V8_CRDTP_PROTOCOL_CORE_H_

package/pods/Headers/inspector/third_party/inspector_protocol/crdtp/serializable.h

@@ -1,32 +0,0 @@
-// Copyright 2019 The Chromium 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_CRDTP_SERIALIZABLE_H_
-#define V8_CRDTP_SERIALIZABLE_H_
-
-#include <cstdint>
-#include <memory>
-#include <vector>
-#include "export.h"
-
-namespace v8_crdtp {
-// =============================================================================
-// Serializable - An object to be emitted as a sequence of bytes.
-// =============================================================================
-class Serializable {
- public:
-  // Convenience: Invokes |AppendSerialized| on an empty vector.
-  std::vector<uint8_t> Serialize() const;
-
-  virtual void AppendSerialized(std::vector<uint8_t>* out) const = 0;
-
-  virtual ~Serializable() = default;
-
-  // Wraps a vector of |bytes| into a Serializable for situations in which we
-  // eagerly serialize a structure.
-  static std::unique_ptr<Serializable> From(std::vector<uint8_t> bytes);
-};
-}  // namespace v8_crdtp
-
-#endif  // V8_CRDTP_SERIALIZABLE_H_

package/pods/Headers/inspector/third_party/inspector_protocol/crdtp/serializer_traits.h

@@ -1,158 +0,0 @@
-// Copyright 2019 The Chromium 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_CRDTP_SERIALIZER_TRAITS_H_
-#define V8_CRDTP_SERIALIZER_TRAITS_H_
-
-#include <memory>
-#include <string>
-#include <vector>
-#include "cbor.h"
-#include "maybe.h"
-#include "span.h"
-
-namespace v8_crdtp {
-// =============================================================================
-// SerializerTraits - Encodes field values of protocol objects in CBOR.
-// =============================================================================
-//
-// A family of serialization functions which are used by FieldSerializerTraits
-// (below) to encode field values in CBOR. Conceptually, it's this:
-//
-// Serialize(bool value, std::vector<uint8_t>* out);
-// Serialize(int32_t value, std::vector<uint8_t>* out);
-// Serialize(double value, std::vector<uint8_t>* out);
-// ...
-//
-// However, if this was to use straight-forward overloading, implicit
-// type conversions would lead to ambiguity - e.g., a bool could be
-// represented as an int32_t, but it should really be encoded as a bool.
-// The template parameterized / specialized structs accomplish this.
-//
-// SerializerTraits<bool>::Serialize(bool value, std::vector<uint8_t>* out);
-// SerializerTraits<int32>::Serialize(int32_t value, std::vector<uint8_t>* out);
-// SerializerTraits<double>::Serialize(double value, std::vector<uint8_t>* out);
-template <typename T>
-struct SerializerTraits {
-  // |Serializable| (defined in serializable.h) already knows how to serialize
-  // to CBOR, so we can just delegate. This covers domain specific types,
-  // protocol::Binary, etc.
-  // However, we use duck-typing here, because Exported, which is part of the V8
-  // headers also comes with AppendSerialized, and logically it's the same type,
-  // but it lives in a different namespace (v8_inspector::protocol::Exported).
-  template <
-      typename LikeSerializable,
-      typename std::enable_if_t<std::is_member_pointer<decltype(
-                                    &LikeSerializable::AppendSerialized)>{},
-                                int> = 0>
-  static void Serialize(const LikeSerializable& value,
-                        std::vector<uint8_t>* out) {
-    value.AppendSerialized(out);
-  }
-};
-
-// This covers std::string, which is assumed to be UTF-8.
-// The two other string implementations that are used in the protocol bindings:
-// - WTF::String, for which the SerializerTraits specialization is located
-//   in third_party/blink/renderer/core/inspector/v8-inspector-string.h.
-// - v8_inspector::String16, implemented in v8/src/inspector/string-16.h
-//   along with its SerializerTraits specialization.
-template <>
-struct SerializerTraits<std::string> {
-  static void Serialize(const std::string& str, std::vector<uint8_t>* out) {
-    cbor::EncodeString8(SpanFrom(str), out);
-  }
-};
-
-template <>
-struct SerializerTraits<bool> {
-  static void Serialize(bool value, std::vector<uint8_t>* out) {
-    out->push_back(value ? cbor::EncodeTrue() : cbor::EncodeFalse());
-  }
-};
-
-template <>
-struct SerializerTraits<int32_t> {
-  static void Serialize(int32_t value, std::vector<uint8_t>* out) {
-    cbor::EncodeInt32(value, out);
-  }
-};
-
-template <>
-struct SerializerTraits<double> {
-  static void Serialize(double value, std::vector<uint8_t>* out) {
-    cbor::EncodeDouble(value, out);
-  }
-};
-
-template <typename T>
-struct SerializerTraits<std::vector<T>> {
-  static void Serialize(const std::vector<T>& value,
-                        std::vector<uint8_t>* out) {
-    out->push_back(cbor::EncodeIndefiniteLengthArrayStart());
-    for (const T& element : value)
-      SerializerTraits<T>::Serialize(element, out);
-    out->push_back(cbor::EncodeStop());
-  }
-};
-
-template <typename T>
-struct SerializerTraits<std::unique_ptr<T>> {
-  static void Serialize(const std::unique_ptr<T>& value,
-                        std::vector<uint8_t>* out) {
-    SerializerTraits<T>::Serialize(*value, out);
-  }
-};
-
-// =============================================================================
-// FieldSerializerTraits - Encodes fields of protocol objects in CBOR
-// =============================================================================
-//
-// The generated code (see TypeBuilder_cpp.template) invokes SerializeField,
-// which then instantiates the FieldSerializerTraits to emit the appropriate
-// existence checks / dereference for the field value. This avoids emitting
-// the field name if the value for an optional field isn't set.
-template <typename T>
-struct FieldSerializerTraits {
-  static void Serialize(span<uint8_t> field_name,
-                        const T& field_value,
-                        std::vector<uint8_t>* out) {
-    cbor::EncodeString8(field_name, out);
-    SerializerTraits<T>::Serialize(field_value, out);
-  }
-};
-
-template <typename T>
-struct FieldSerializerTraits<detail::PtrMaybe<T>> {
-  static void Serialize(span<uint8_t> field_name,
-                        const detail::PtrMaybe<T>& field_value,
-                        std::vector<uint8_t>* out) {
-    if (!field_value.isJust())
-      return;
-    cbor::EncodeString8(field_name, out);
-    SerializerTraits<T>::Serialize(*field_value.fromJust(), out);
-  }
-};
-
-template <typename T>
-struct FieldSerializerTraits<detail::ValueMaybe<T>> {
-  static void Serialize(span<uint8_t> field_name,
-                        const detail::ValueMaybe<T>& field_value,
-                        std::vector<uint8_t>* out) {
-    if (!field_value.isJust())
-      return;
-    cbor::EncodeString8(field_name, out);
-    SerializerTraits<T>::Serialize(field_value.fromJust(), out);
-  }
-};
-
-template <typename T>
-void SerializeField(span<uint8_t> field_name,
-                    const T& field_value,
-                    std::vector<uint8_t>* out) {
-  FieldSerializerTraits<T>::Serialize(field_name, field_value, out);
-}
-}  // namespace v8_crdtp
-
-#endif  // V8_CRDTP_SERIALIZER_TRAITS_H_

package/pods/Headers/inspector/third_party/inspector_protocol/crdtp/span.h

@@ -1,99 +0,0 @@
-// Copyright 2019 The Chromium 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_CRDTP_SPAN_H_
-#define V8_CRDTP_SPAN_H_
-
-#include <cstdint>
-#include <cstring>
-#include <string>
-
-#include "export.h"
-
-namespace v8_crdtp {
-// =============================================================================
-// span - sequence of bytes
-// =============================================================================
-
-// This template is similar to std::span, which will be included in C++20.
-template <typename T>
-class span {
- public:
-  using index_type = size_t;
-
-  constexpr span() : data_(nullptr), size_(0) {}
-  constexpr span(const T* data, index_type size) : data_(data), size_(size) {}
-
-  constexpr const T* data() const { return data_; }
-
-  constexpr const T* begin() const { return data_; }
-  constexpr const T* end() const { return data_ + size_; }
-
-  constexpr const T& operator[](index_type idx) const { return data_[idx]; }
-
-  constexpr span<T> subspan(index_type offset, index_type count) const {
-    return span(data_ + offset, count);
-  }
-
-  constexpr span<T> subspan(index_type offset) const {
-    return span(data_ + offset, size_ - offset);
-  }
-
-  constexpr bool empty() const { return size_ == 0; }
-
-  constexpr index_type size() const { return size_; }
-  constexpr index_type size_bytes() const { return size_ * sizeof(T); }
-
- private:
-  const T* data_;
-  index_type size_;
-};
-
-template <size_t N>
-constexpr span<char> MakeSpan(const char (&str)[N]) {
-  return span<char>(str, N - 1);
-}
-
-template <size_t N>
-constexpr span<uint8_t> SpanFrom(const char (&str)[N]) {
-  return span<uint8_t>(reinterpret_cast<const uint8_t*>(str), N - 1);
-}
-
-constexpr inline span<uint8_t> SpanFrom(const char* str) {
-  return str ? span<uint8_t>(reinterpret_cast<const uint8_t*>(str), strlen(str))
-             : span<uint8_t>();
-}
-
-inline span<uint8_t> SpanFrom(const std::string& v) {
-  return span<uint8_t>(reinterpret_cast<const uint8_t*>(v.data()), v.size());
-}
-
-// This SpanFrom routine works for std::vector<uint8_t> and
-// std::vector<uint16_t>, but also for base::span<const uint8_t> in Chromium.
-template <typename C,
-          typename = std::enable_if_t<
-              std::is_unsigned<typename C::value_type>{} &&
-              std::is_member_function_pointer<decltype(&C::size)>{}>>
-inline span<typename C::value_type> SpanFrom(const C& v) {
-  return span<typename C::value_type>(v.data(), v.size());
-}
-
-// Less than / equality comparison functions for sorting / searching for byte
-// spans.
-bool SpanLessThan(span<uint8_t> x, span<uint8_t> y) noexcept;
-bool SpanEquals(span<uint8_t> x, span<uint8_t> y) noexcept;
-
-// Less than / equality comparison functions for sorting / searching for byte
-// spans.
-bool SpanLessThan(span<char> x, span<char> y) noexcept;
-bool SpanEquals(span<char> x, span<char> y) noexcept;
-
-struct SpanLt {
-  bool operator()(span<uint8_t> l, span<uint8_t> r) const {
-    return SpanLessThan(l, r);
-  }
-};
-}  // namespace v8_crdtp
-
-#endif  // V8_CRDTP_SPAN_H_