@contrast/agent 4.5.0 → 4.7.0

package/node_modules/nan/nan_persistent_pre_12_inl.h

@@ -1,242 +0,0 @@
-/*********************************************************************
- * NAN - Native Abstractions for Node.js
- *
- * Copyright (c) 2018 NAN contributors
- *
- * MIT License <https://github.com/nodejs/nan/blob/master/LICENSE.md>
- ********************************************************************/
-
-#ifndef NAN_PERSISTENT_PRE_12_INL_H_
-#define NAN_PERSISTENT_PRE_12_INL_H_
-
-template<typename T>
-class PersistentBase {
-  v8::Persistent<T> persistent;
-  template<typename U>
-  friend v8::Local<U> New(const PersistentBase<U> &p);
-  template<typename U, typename M>
-  friend v8::Local<U> New(const Persistent<U, M> &p);
-  template<typename U>
-  friend v8::Local<U> New(const Global<U> &p);
-  template<typename S> friend class ReturnValue;
-
- public:
-  inline PersistentBase() :
-      persistent() {}
-
-  inline void Reset() {
-    persistent.Dispose();
-    persistent.Clear();
-  }
-
-  template<typename S>
-  inline void Reset(const v8::Local<S> &other) {
-    TYPE_CHECK(T, S);
-
-    if (!persistent.IsEmpty()) {
-      persistent.Dispose();
-    }
-
-    if (other.IsEmpty()) {
-      persistent.Clear();
-    } else {
-      persistent = v8::Persistent<T>::New(other);
-    }
-  }
-
-  template<typename S>
-  inline void Reset(const PersistentBase<S> &other) {
-    TYPE_CHECK(T, S);
-
-    if (!persistent.IsEmpty()) {
-      persistent.Dispose();
-    }
-
-    if (other.IsEmpty()) {
-      persistent.Clear();
-    } else {
-      persistent = v8::Persistent<T>::New(other.persistent);
-    }
-  }
-
-  inline bool IsEmpty() const { return persistent.IsEmpty(); }
-
-  inline void Empty() { persistent.Clear(); }
-
-  template<typename S>
-  inline bool operator==(const PersistentBase<S> &that) const {
-    return this->persistent == that.persistent;
-  }
-
-  template<typename S>
-  inline bool operator==(const v8::Local<S> &that) const {
-    return this->persistent == that;
-  }
-
-  template<typename S>
-  inline bool operator!=(const PersistentBase<S> &that) const {
-    return !operator==(that);
-  }
-
-  template<typename S>
-  inline bool operator!=(const v8::Local<S> &that) const {
-    return !operator==(that);
-  }
-
-  template<typename P>
-  inline void SetWeak(
-    P *parameter
-    , typename WeakCallbackInfo<P>::Callback callback
-    , WeakCallbackType type);
-
-  inline void ClearWeak() { persistent.ClearWeak(); }
-
-  inline void MarkIndependent() { persistent.MarkIndependent(); }
-
-  inline bool IsIndependent() const { return persistent.IsIndependent(); }
-
-  inline bool IsNearDeath() const { return persistent.IsNearDeath(); }
-
-  inline bool IsWeak() const { return persistent.IsWeak(); }
-
- private:
-  inline explicit PersistentBase(v8::Persistent<T> that) :
-      persistent(that) { }
-  inline explicit PersistentBase(T *val) : persistent(val) {}
-  template<typename S, typename M> friend class Persistent;
-  template<typename S> friend class Global;
-  friend class ObjectWrap;
-};
-
-template<typename T>
-class NonCopyablePersistentTraits {
- public:
-  typedef Persistent<T, NonCopyablePersistentTraits<T> >
-      NonCopyablePersistent;
-  static const bool kResetInDestructor = false;
-  template<typename S, typename M>
-  inline static void Copy(const Persistent<S, M> &source,
-                             NonCopyablePersistent *dest) {
-    Uncompilable<v8::Object>();
-  }
-
-  template<typename O> inline static void Uncompilable() {
-    TYPE_CHECK(O, v8::Primitive);
-  }
-};
-
-template<typename T>
-struct CopyablePersistentTraits {
-  typedef Persistent<T, CopyablePersistentTraits<T> > CopyablePersistent;
-  static const bool kResetInDestructor = true;
-  template<typename S, typename M>
-  static inline void Copy(const Persistent<S, M> &source,
-                             CopyablePersistent *dest) {}
-};
-
-template<typename T, typename M> class Persistent :
-    public PersistentBase<T> {
- public:
-  inline Persistent() {}
-
-  template<typename S> inline Persistent(v8::Handle<S> that)
-      : PersistentBase<T>(v8::Persistent<T>::New(that)) {
-    TYPE_CHECK(T, S);
-  }
-
-  inline Persistent(const Persistent &that) : PersistentBase<T>() {
-    Copy(that);
-  }
-
-  template<typename S, typename M2>
-  inline Persistent(const Persistent<S, M2> &that) :
-      PersistentBase<T>() {
-    Copy(that);
-  }
-
-  inline Persistent &operator=(const Persistent &that) {
-    Copy(that);
-    return *this;
-  }
-
-  template <class S, class M2>
-  inline Persistent &operator=(const Persistent<S, M2> &that) {
-    Copy(that);
-    return *this;
-  }
-
-  inline ~Persistent() {
-    if (M::kResetInDestructor) this->Reset();
-  }
-
- private:
-  inline T *operator*() const { return *PersistentBase<T>::persistent; }
-
-  template<typename S, typename M2>
-  inline void Copy(const Persistent<S, M2> &that) {
-    TYPE_CHECK(T, S);
-
-    this->Reset();
-
-    if (!that.IsEmpty()) {
-      this->persistent = v8::Persistent<T>::New(that.persistent);
-      M::Copy(that, this);
-    }
-  }
-};
-
-template<typename T>
-class Global : public PersistentBase<T> {
-  struct RValue {
-    inline explicit RValue(Global* obj) : object(obj) {}
-    Global* object;
-  };
-
- public:
-  inline Global() : PersistentBase<T>(0) { }
-
-  template <typename S>
-  inline Global(v8::Local<S> that)  // NOLINT(runtime/explicit)
-      : PersistentBase<T>(v8::Persistent<T>::New(that)) {
-    TYPE_CHECK(T, S);
-  }
-
-  template <typename S>
-  inline Global(const PersistentBase<S> &that)  // NOLINT(runtime/explicit)
-    : PersistentBase<T>(that) {
-    TYPE_CHECK(T, S);
-  }
-  /**
-   * Move constructor.
-   */
-  inline Global(RValue rvalue)  // NOLINT(runtime/explicit)
-    : PersistentBase<T>(rvalue.object->persistent) {
-    rvalue.object->Reset();
-  }
-  inline ~Global() { this->Reset(); }
-  /**
-   * Move via assignment.
-   */
-  template<typename S>
-  inline Global &operator=(Global<S> rhs) {
-    TYPE_CHECK(T, S);
-    this->Reset(rhs.persistent);
-    rhs.Reset();
-    return *this;
-  }
-  /**
-   * Cast operator for moves.
-   */
-  inline operator RValue() { return RValue(this); }
-  /**
-   * Pass allows returning uniques from functions, etc.
-   */
-  Global Pass() { return Global(RValue(this)); }
-
- private:
-  Global(Global &);
-  void operator=(Global &);
-  template<typename S> friend class ReturnValue;
-};
-
-#endif  // NAN_PERSISTENT_PRE_12_INL_H_

package/node_modules/nan/nan_private.h

@@ -1,73 +0,0 @@
-/*********************************************************************
- * NAN - Native Abstractions for Node.js
- *
- * Copyright (c) 2018 NAN contributors
- *
- * MIT License <https://github.com/nodejs/nan/blob/master/LICENSE.md>
- ********************************************************************/
-
-#ifndef NAN_PRIVATE_H_
-#define NAN_PRIVATE_H_
-
-inline Maybe<bool>
-HasPrivate(v8::Local<v8::Object> object, v8::Local<v8::String> key) {
-  HandleScope scope;
-#if NODE_MODULE_VERSION >= NODE_6_0_MODULE_VERSION
-  v8::Isolate *isolate = v8::Isolate::GetCurrent();
-  v8::Local<v8::Context> context = isolate->GetCurrentContext();
-  v8::Local<v8::Private> private_key = v8::Private::ForApi(isolate, key);
-  return object->HasPrivate(context, private_key);
-#else
-  return Just(!object->GetHiddenValue(key).IsEmpty());
-#endif
-}
-
-inline MaybeLocal<v8::Value>
-GetPrivate(v8::Local<v8::Object> object, v8::Local<v8::String> key) {
-#if NODE_MODULE_VERSION >= NODE_6_0_MODULE_VERSION
-  v8::Isolate *isolate = v8::Isolate::GetCurrent();
-  v8::EscapableHandleScope scope(isolate);
-  v8::Local<v8::Context> context = isolate->GetCurrentContext();
-  v8::Local<v8::Private> private_key = v8::Private::ForApi(isolate, key);
-  v8::MaybeLocal<v8::Value> v = object->GetPrivate(context, private_key);
-  return scope.Escape(v.ToLocalChecked());
-#else
-  EscapableHandleScope scope;
-  v8::Local<v8::Value> v = object->GetHiddenValue(key);
-  if (v.IsEmpty()) {
-    v = Undefined();
-  }
-  return scope.Escape(v);
-#endif
-}
-
-inline Maybe<bool> SetPrivate(
-    v8::Local<v8::Object> object,
-    v8::Local<v8::String> key,
-    v8::Local<v8::Value> value) {
-#if NODE_MODULE_VERSION >= NODE_6_0_MODULE_VERSION
-  HandleScope scope;
-  v8::Isolate *isolate = v8::Isolate::GetCurrent();
-  v8::Local<v8::Context> context = isolate->GetCurrentContext();
-  v8::Local<v8::Private> private_key = v8::Private::ForApi(isolate, key);
-  return object->SetPrivate(context, private_key, value);
-#else
-  return Just(object->SetHiddenValue(key, value));
-#endif
-}
-
-inline Maybe<bool> DeletePrivate(
-    v8::Local<v8::Object> object,
-    v8::Local<v8::String> key) {
-#if NODE_MODULE_VERSION >= NODE_6_0_MODULE_VERSION
-  HandleScope scope;
-  v8::Isolate *isolate = v8::Isolate::GetCurrent();
-  v8::Local<v8::Private> private_key = v8::Private::ForApi(isolate, key);
-  return object->DeletePrivate(isolate->GetCurrentContext(), private_key);
-#else
-  return Just(object->DeleteHiddenValue(key));
-#endif
-}
-
-#endif  // NAN_PRIVATE_H_
-

package/node_modules/nan/nan_string_bytes.h

@@ -1,305 +0,0 @@
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-#ifndef NAN_STRING_BYTES_H_
-#define NAN_STRING_BYTES_H_
-
-// Decodes a v8::Local<v8::String> or Buffer to a raw char*
-
-namespace imp {
-
-using v8::Local;
-using v8::Object;
-using v8::String;
-using v8::Value;
-
-
-//// Base 64 ////
-
-#define base64_encoded_size(size) ((size + 2 - ((size + 2) % 3)) / 3 * 4)
-
-
-
-//// HEX ////
-
-static bool contains_non_ascii_slow(const char* buf, size_t len) {
-  for (size_t i = 0; i < len; ++i) {
-    if (buf[i] & 0x80) return true;
-  }
-  return false;
-}
-
-
-static bool contains_non_ascii(const char* src, size_t len) {
-  if (len < 16) {
-    return contains_non_ascii_slow(src, len);
-  }
-
-  const unsigned bytes_per_word = sizeof(void*);
-  const unsigned align_mask = bytes_per_word - 1;
-  const unsigned unaligned = reinterpret_cast<uintptr_t>(src) & align_mask;
-
-  if (unaligned > 0) {
-    const unsigned n = bytes_per_word - unaligned;
-    if (contains_non_ascii_slow(src, n)) return true;
-    src += n;
-    len -= n;
-  }
-
-
-#if defined(__x86_64__) || defined(_WIN64)
-  const uintptr_t mask = 0x8080808080808080ll;
-#else
-  const uintptr_t mask = 0x80808080l;
-#endif
-
-  const uintptr_t* srcw = reinterpret_cast<const uintptr_t*>(src);
-
-  for (size_t i = 0, n = len / bytes_per_word; i < n; ++i) {
-    if (srcw[i] & mask) return true;
-  }
-
-  const unsigned remainder = len & align_mask;
-  if (remainder > 0) {
-    const size_t offset = len - remainder;
-    if (contains_non_ascii_slow(src + offset, remainder)) return true;
-  }
-
-  return false;
-}
-
-
-static void force_ascii_slow(const char* src, char* dst, size_t len) {
-  for (size_t i = 0; i < len; ++i) {
-    dst[i] = src[i] & 0x7f;
-  }
-}
-
-
-static void force_ascii(const char* src, char* dst, size_t len) {
-  if (len < 16) {
-    force_ascii_slow(src, dst, len);
-    return;
-  }
-
-  const unsigned bytes_per_word = sizeof(void*);
-  const unsigned align_mask = bytes_per_word - 1;
-  const unsigned src_unalign = reinterpret_cast<uintptr_t>(src) & align_mask;
-  const unsigned dst_unalign = reinterpret_cast<uintptr_t>(dst) & align_mask;
-
-  if (src_unalign > 0) {
-    if (src_unalign == dst_unalign) {
-      const unsigned unalign = bytes_per_word - src_unalign;
-      force_ascii_slow(src, dst, unalign);
-      src += unalign;
-      dst += unalign;
-      len -= src_unalign;
-    } else {
-      force_ascii_slow(src, dst, len);
-      return;
-    }
-  }
-
-#if defined(__x86_64__) || defined(_WIN64)
-  const uintptr_t mask = ~0x8080808080808080ll;
-#else
-  const uintptr_t mask = ~0x80808080l;
-#endif
-
-  const uintptr_t* srcw = reinterpret_cast<const uintptr_t*>(src);
-  uintptr_t* dstw = reinterpret_cast<uintptr_t*>(dst);
-
-  for (size_t i = 0, n = len / bytes_per_word; i < n; ++i) {
-    dstw[i] = srcw[i] & mask;
-  }
-
-  const unsigned remainder = len & align_mask;
-  if (remainder > 0) {
-    const size_t offset = len - remainder;
-    force_ascii_slow(src + offset, dst + offset, remainder);
-  }
-}
-
-
-static size_t base64_encode(const char* src,
-                            size_t slen,
-                            char* dst,
-                            size_t dlen) {
-  // We know how much we'll write, just make sure that there's space.
-  assert(dlen >= base64_encoded_size(slen) &&
-      "not enough space provided for base64 encode");
-
-  dlen = base64_encoded_size(slen);
-
-  unsigned a;
-  unsigned b;
-  unsigned c;
-  unsigned i;
-  unsigned k;
-  unsigned n;
-
-  static const char table[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
-                              "abcdefghijklmnopqrstuvwxyz"
-                              "0123456789+/";
-
-  i = 0;
-  k = 0;
-  n = slen / 3 * 3;
-
-  while (i < n) {
-    a = src[i + 0] & 0xff;
-    b = src[i + 1] & 0xff;
-    c = src[i + 2] & 0xff;
-
-    dst[k + 0] = table[a >> 2];
-    dst[k + 1] = table[((a & 3) << 4) | (b >> 4)];
-    dst[k + 2] = table[((b & 0x0f) << 2) | (c >> 6)];
-    dst[k + 3] = table[c & 0x3f];
-
-    i += 3;
-    k += 4;
-  }
-
-  if (n != slen) {
-    switch (slen - n) {
-      case 1:
-        a = src[i + 0] & 0xff;
-        dst[k + 0] = table[a >> 2];
-        dst[k + 1] = table[(a & 3) << 4];
-        dst[k + 2] = '=';
-        dst[k + 3] = '=';
-        break;
-
-      case 2:
-        a = src[i + 0] & 0xff;
-        b = src[i + 1] & 0xff;
-        dst[k + 0] = table[a >> 2];
-        dst[k + 1] = table[((a & 3) << 4) | (b >> 4)];
-        dst[k + 2] = table[(b & 0x0f) << 2];
-        dst[k + 3] = '=';
-        break;
-    }
-  }
-
-  return dlen;
-}
-
-
-static size_t hex_encode(const char* src, size_t slen, char* dst, size_t dlen) {
-  // We know how much we'll write, just make sure that there's space.
-  assert(dlen >= slen * 2 &&
-      "not enough space provided for hex encode");
-
-  dlen = slen * 2;
-  for (uint32_t i = 0, k = 0; k < dlen; i += 1, k += 2) {
-    static const char hex[] = "0123456789abcdef";
-    uint8_t val = static_cast<uint8_t>(src[i]);
-    dst[k + 0] = hex[val >> 4];
-    dst[k + 1] = hex[val & 15];
-  }
-
-  return dlen;
-}
-
-
-
-static Local<Value> Encode(const char* buf,
-                           size_t buflen,
-                           enum Encoding encoding) {
-  assert(buflen <= node::Buffer::kMaxLength);
-  if (!buflen && encoding != BUFFER)
-    return New("").ToLocalChecked();
-
-  Local<String> val;
-  switch (encoding) {
-    case BUFFER:
-      return CopyBuffer(buf, buflen).ToLocalChecked();
-
-    case ASCII:
-      if (contains_non_ascii(buf, buflen)) {
-        char* out = new char[buflen];
-        force_ascii(buf, out, buflen);
-        val = New<String>(out, buflen).ToLocalChecked();
-        delete[] out;
-      } else {
-        val = New<String>(buf, buflen).ToLocalChecked();
-      }
-      break;
-
-    case UTF8:
-      val = New<String>(buf, buflen).ToLocalChecked();
-      break;
-
-    case BINARY: {
-      // TODO(isaacs) use ExternalTwoByteString?
-      const unsigned char *cbuf = reinterpret_cast<const unsigned char*>(buf);
-      uint16_t * twobytebuf = new uint16_t[buflen];
-      for (size_t i = 0; i < buflen; i++) {
-        // XXX is the following line platform independent?
-        twobytebuf[i] = cbuf[i];
-      }
-      val = New<String>(twobytebuf, buflen).ToLocalChecked();
-      delete[] twobytebuf;
-      break;
-    }
-
-    case BASE64: {
-      size_t dlen = base64_encoded_size(buflen);
-      char* dst = new char[dlen];
-
-      size_t written = base64_encode(buf, buflen, dst, dlen);
-      assert(written == dlen);
-
-      val = New<String>(dst, dlen).ToLocalChecked();
-      delete[] dst;
-      break;
-    }
-
-    case UCS2: {
-      const uint16_t* data = reinterpret_cast<const uint16_t*>(buf);
-      val = New<String>(data, buflen / 2).ToLocalChecked();
-      break;
-    }
-
-    case HEX: {
-      size_t dlen = buflen * 2;
-      char* dst = new char[dlen];
-      size_t written = hex_encode(buf, buflen, dst, dlen);
-      assert(written == dlen);
-
-      val = New<String>(dst, dlen).ToLocalChecked();
-      delete[] dst;
-      break;
-    }
-
-    default:
-      assert(0 && "unknown encoding");
-      break;
-  }
-
-  return val;
-}
-
-#undef base64_encoded_size
-
-}  // end of namespace imp
-
-#endif  // NAN_STRING_BYTES_H_

package/node_modules/nan/nan_typedarray_contents.h

@@ -1,96 +0,0 @@
-/*********************************************************************
- * NAN - Native Abstractions for Node.js
- *
- * Copyright (c) 2018 NAN contributors
- *
- * MIT License <https://github.com/nodejs/nan/blob/master/LICENSE.md>
- ********************************************************************/
-
-#ifndef NAN_TYPEDARRAY_CONTENTS_H_
-#define NAN_TYPEDARRAY_CONTENTS_H_
-
-template<typename T>
-class TypedArrayContents {
- public:
-  inline explicit TypedArrayContents(v8::Local<v8::Value> from) :
-      length_(0), data_(NULL) {
-    HandleScope scope;
-
-    size_t length = 0;
-    void*  data = NULL;
-
-#if defined(V8_MAJOR_VERSION) && (V8_MAJOR_VERSION > 4 ||                      \
-  (V8_MAJOR_VERSION == 4 && defined(V8_MINOR_VERSION) && V8_MINOR_VERSION >= 3))
-
-    if (from->IsArrayBufferView()) {
-      v8::Local<v8::ArrayBufferView> array =
-        v8::Local<v8::ArrayBufferView>::Cast(from);
-
-      const size_t    byte_length = array->ByteLength();
-      const ptrdiff_t byte_offset = array->ByteOffset();
-      v8::Local<v8::ArrayBuffer> buffer = array->Buffer();
-
-      length = byte_length / sizeof(T);
-// Actually it's 7.9 here but this would lead to ABI issues with Node.js 13
-// using 7.8 till 13.2.0.
-#if (V8_MAJOR_VERSION >= 8)
-      data = static_cast<char*>(buffer->GetBackingStore()->Data()) + byte_offset;
-#else
-      data = static_cast<char*>(buffer->GetContents().Data()) + byte_offset;
-#endif
-    }
-
-#else
-
-    if (from->IsObject() && !from->IsNull()) {
-      v8::Local<v8::Object> array = v8::Local<v8::Object>::Cast(from);
-
-      MaybeLocal<v8::Value> buffer = Get(array,
-        New<v8::String>("buffer").ToLocalChecked());
-      MaybeLocal<v8::Value> byte_length = Get(array,
-        New<v8::String>("byteLength").ToLocalChecked());
-      MaybeLocal<v8::Value> byte_offset = Get(array,
-        New<v8::String>("byteOffset").ToLocalChecked());
-
-      if (!buffer.IsEmpty() &&
-          !byte_length.IsEmpty() && byte_length.ToLocalChecked()->IsUint32() &&
-          !byte_offset.IsEmpty() && byte_offset.ToLocalChecked()->IsUint32()) {
-        data = array->GetIndexedPropertiesExternalArrayData();
-        if(data) {
-          length = byte_length.ToLocalChecked()->Uint32Value() / sizeof(T);
-        }
-      }
-    }
-
-#endif
-
-#if defined(_MSC_VER) && _MSC_VER >= 1900 || __cplusplus >= 201103L
-    assert(reinterpret_cast<uintptr_t>(data) % alignof (T) == 0);
-#elif defined(_MSC_VER) && _MSC_VER >= 1600 || defined(__GNUC__)
-    assert(reinterpret_cast<uintptr_t>(data) % __alignof(T) == 0);
-#else
-    assert(reinterpret_cast<uintptr_t>(data) % sizeof (T) == 0);
-#endif
-
-    length_ = length;
-    data_   = static_cast<T*>(data);
-  }
-
-  inline size_t length() const      { return length_; }
-  inline T* operator*()             { return data_;   }
-  inline const T* operator*() const { return data_;   }
-
- private:
-  NAN_DISALLOW_ASSIGN_COPY_MOVE(TypedArrayContents)
-
-  //Disable heap allocation
-  void *operator new(size_t size);
-  void operator delete(void *, size_t) {
-    abort();
-  }
-
-  size_t  length_;
-  T*      data_;
-};
-
-#endif  // NAN_TYPEDARRAY_CONTENTS_H_