@triniwiz/nativescript-masonkit 1.0.0-alpha.5 → 1.0.0-alpha.7

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

@@ -0,0 +1,406 @@
+// 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

@@ -0,0 +1,32 @@
+// 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

@@ -0,0 +1,158 @@
+// 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

@@ -0,0 +1,99 @@
+// 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_