hooch 0.0.5 → 0.0.6

data/jasmine/node_modules/karma/node_modules/socket.io/node_modules/socket.io-client/node_modules/ws/node_modules/nan/build/config.gypi

@@ -0,0 +1,38 @@
+# Do not edit. File was generated by node-gyp's "configure" step
+{
+  "target_defaults": {
+    "cflags": [],
+    "default_configuration": "Release",
+    "defines": [],
+    "include_dirs": [],
+    "libraries": []
+  },
+  "variables": {
+    "clang": 0,
+    "gcc_version": 47,
+    "host_arch": "x64",
+    "node_install_npm": "true",
+    "node_prefix": "",
+    "node_shared_cares": "false",
+    "node_shared_http_parser": "false",
+    "node_shared_libuv": "false",
+    "node_shared_openssl": "false",
+    "node_shared_v8": "false",
+    "node_shared_zlib": "false",
+    "node_tag": "",
+    "node_unsafe_optimizations": 0,
+    "node_use_dtrace": "false",
+    "node_use_etw": "false",
+    "node_use_openssl": "true",
+    "node_use_perfctr": "false",
+    "node_use_systemtap": "false",
+    "python": "/usr/bin/python",
+    "target_arch": "x64",
+    "v8_enable_gdbjit": 0,
+    "v8_no_strict_aliasing": 1,
+    "v8_use_snapshot": "true",
+    "nodedir": "/home/rvagg/.node-gyp/0.10.21",
+    "copy_dev_lib": "true",
+    "standalone_static_library": 1
+  }
+}

data/jasmine/node_modules/karma/node_modules/socket.io/node_modules/socket.io-client/node_modules/ws/node_modules/nan/include_dirs.js

@@ -0,0 +1 @@
+console.log(require('path').relative('.', __dirname));

data/jasmine/node_modules/karma/node_modules/socket.io/node_modules/socket.io-client/node_modules/ws/node_modules/nan/nan.h

@@ -0,0 +1,1910 @@
+/**********************************************************************************
+ * NAN - Native Abstractions for Node.js
+ *
+ * Copyright (c) 2014 NAN contributors:
+ *   - Rod Vagg <https://github.com/rvagg>
+ *   - Benjamin Byholm <https://github.com/kkoopa>
+ *   - Trevor Norris <https://github.com/trevnorris>
+ *   - Nathan Rajlich <https://github.com/TooTallNate>
+ *   - Brett Lawson <https://github.com/brett19>
+ *   - Ben Noordhuis <https://github.com/bnoordhuis>
+ *
+ * MIT +no-false-attribs License <https://github.com/rvagg/nan/blob/master/LICENSE>
+ *
+ * Version 1.0.0 (current Node unstable: 0.11.13, Node stable: 0.10.28)
+ *
+ * ChangeLog:
+ *  * 1.0.0 May 4 2014
+ *    - Heavy API changes for V8 3.25 / Node 0.11.13
+ *    - Use cpplint.py
+ *    - Removed NanInitPersistent
+ *    - Removed NanPersistentToLocal
+ *    - Removed NanFromV8String
+ *    - Removed NanMakeWeak
+ *    - Removed NanNewLocal
+ *    - Removed NAN_WEAK_CALLBACK_OBJECT
+ *    - Removed NAN_WEAK_CALLBACK_DATA
+ *    - Introduce NanNew, replaces NanNewLocal, NanPersistentToLocal, adds many overloaded typed versions
+ *    - Introduce NanUndefined, NanNull, NanTrue and NanFalse
+ *    - Introduce NanEscapableScope and NanEscapeScope
+ *    - Introduce NanMakeWeakPersistent (requires a special callback to work on both old and new node)
+ *    - Introduce NanMakeCallback for node::MakeCallback
+ *    - Introduce NanSetTemplate
+ *    - Introduce NanGetCurrentContext
+ *    - Introduce NanCompileScript and NanRunScript
+ *    - Introduce NanAdjustExternalMemory
+ *    - Introduce NanAddGCEpilogueCallback, NanAddGCPrologueCallback, NanRemoveGCEpilogueCallback, NanRemoveGCPrologueCallback
+ *    - Introduce NanGetHeapStatistics
+ *    - Rename NanAsyncWorker#SavePersistent() to SaveToPersistent()
+ *
+ *  * 0.8.0 Jan 9 2014
+ *    - NanDispose -> NanDisposePersistent, deprecate NanDispose
+ *    - Extract _NAN_*_RETURN_TYPE, pull up NAN_*()
+ *
+ *  * 0.7.1 Jan 9 2014
+ *    - Fixes to work against debug builds of Node
+ *    - Safer NanPersistentToLocal (avoid reinterpret_cast)
+ *    - Speed up common NanRawString case by only extracting flattened string when necessary
+ *
+ *  * 0.7.0 Dec 17 2013
+ *    - New no-arg form of NanCallback() constructor.
+ *    - NanCallback#Call takes Handle rather than Local
+ *    - Removed deprecated NanCallback#Run method, use NanCallback#Call instead
+ *    - Split off _NAN_*_ARGS_TYPE from _NAN_*_ARGS
+ *    - Restore (unofficial) Node 0.6 compatibility at NanCallback#Call()
+ *    - Introduce NanRawString() for char* (or appropriate void*) from v8::String
+ *      (replacement for NanFromV8String)
+ *    - Introduce NanCString() for null-terminated char* from v8::String
+ *
+ *  * 0.6.0 Nov 21 2013
+ *    - Introduce NanNewLocal<T>(v8::Handle<T> value) for use in place of
+ *      v8::Local<T>::New(...) since v8 started requiring isolate in Node 0.11.9
+ *
+ *  * 0.5.2 Nov 16 2013
+ *    - Convert SavePersistent and GetFromPersistent in NanAsyncWorker from protected and public
+ *
+ *  * 0.5.1 Nov 12 2013
+ *    - Use node::MakeCallback() instead of direct v8::Function::Call()
+ *
+ *  * 0.5.0 Nov 11 2013
+ *    - Added @TooTallNate as collaborator
+ *    - New, much simpler, "include_dirs" for binding.gyp
+ *    - Added full range of NAN_INDEX_* macros to match NAN_PROPERTY_* macros
+ *
+ *  * 0.4.4 Nov 2 2013
+ *    - Isolate argument from v8::Persistent::MakeWeak removed for 0.11.8+
+ *
+ *  * 0.4.3 Nov 2 2013
+ *    - Include node_object_wrap.h, removed from node.h for Node 0.11.8.
+ *
+ *  * 0.4.2 Nov 2 2013
+ *    - Handle deprecation of v8::Persistent::Dispose(v8::Isolate* isolate)) for
+ *      Node 0.11.8 release.
+ *
+ *  * 0.4.1 Sep 16 2013
+ *    - Added explicit `#include <uv.h>` as it was removed from node.h for v0.11.8
+ *
+ *  * 0.4.0 Sep 2 2013
+ *    - Added NAN_INLINE and NAN_DEPRECATED and made use of them
+ *    - Added NanError, NanTypeError and NanRangeError
+ *    - Cleaned up code
+ *
+ *  * 0.3.2 Aug 30 2013
+ *    - Fix missing scope declaration in GetFromPersistent() and SaveToPersistent
+ *      in NanAsyncWorker
+ *
+ *  * 0.3.1 Aug 20 2013
+ *    - fix "not all control paths return a value" compile warning on some platforms
+ *
+ *  * 0.3.0 Aug 19 2013
+ *    - Made NAN work with NPM
+ *    - Lots of fixes to NanFromV8String, pulling in features from new Node core
+ *    - Changed node::encoding to Nan::Encoding in NanFromV8String to unify the API
+ *    - Added optional error number argument for NanThrowError()
+ *    - Added NanInitPersistent()
+ *    - Added NanReturnNull() and NanReturnEmptyString()
+ *    - Added NanLocker and NanUnlocker
+ *    - Added missing scopes
+ *    - Made sure to clear disposed Persistent handles
+ *    - Changed NanAsyncWorker to allocate error messages on the heap
+ *    - Changed NanThrowError(Local<Value>) to NanThrowError(Handle<Value>)
+ *    - Fixed leak in NanAsyncWorker when errmsg is used
+ *
+ *  * 0.2.2 Aug 5 2013
+ *    - Fixed usage of undefined variable with node::BASE64 in NanFromV8String()
+ *
+ *  * 0.2.1 Aug 5 2013
+ *    - Fixed 0.8 breakage, node::BUFFER encoding type not available in 0.8 for
+ *      NanFromV8String()
+ *
+ *  * 0.2.0 Aug 5 2013
+ *    - Added NAN_PROPERTY_GETTER, NAN_PROPERTY_SETTER, NAN_PROPERTY_ENUMERATOR,
+ *      NAN_PROPERTY_DELETER, NAN_PROPERTY_QUERY
+ *    - Extracted _NAN_METHOD_ARGS, _NAN_GETTER_ARGS, _NAN_SETTER_ARGS,
+ *      _NAN_PROPERTY_GETTER_ARGS, _NAN_PROPERTY_SETTER_ARGS,
+ *      _NAN_PROPERTY_ENUMERATOR_ARGS, _NAN_PROPERTY_DELETER_ARGS,
+ *      _NAN_PROPERTY_QUERY_ARGS
+ *    - Added NanGetInternalFieldPointer, NanSetInternalFieldPointer
+ *    - Added NAN_WEAK_CALLBACK, NAN_WEAK_CALLBACK_OBJECT,
+ *      NAN_WEAK_CALLBACK_DATA, NanMakeWeak
+ *    - Renamed THROW_ERROR to _NAN_THROW_ERROR
+ *    - Added NanNewBufferHandle(char*, size_t, node::smalloc::FreeCallback, void*)
+ *    - Added NanBufferUse(char*, uint32_t)
+ *    - Added NanNewContextHandle(v8::ExtensionConfiguration*,
+ *        v8::Handle<v8::ObjectTemplate>, v8::Handle<v8::Value>)
+ *    - Fixed broken NanCallback#GetFunction()
+ *    - Added optional encoding and size arguments to NanFromV8String()
+ *    - Added NanGetPointerSafe() and NanSetPointerSafe()
+ *    - Added initial test suite (to be expanded)
+ *    - Allow NanUInt32OptionValue to convert any Number object
+ *
+ *  * 0.1.0 Jul 21 2013
+ *    - Added `NAN_GETTER`, `NAN_SETTER`
+ *    - Added `NanThrowError` with single Local<Value> argument
+ *    - Added `NanNewBufferHandle` with single uint32_t argument
+ *    - Added `NanHasInstance(Persistent<FunctionTemplate>&, Handle<Value>)`
+ *    - Added `Local<Function> NanCallback#GetFunction()`
+ *    - Added `NanCallback#Call(int, Local<Value>[])`
+ *    - Deprecated `NanCallback#Run(int, Local<Value>[])` in favour of Call
+ *
+ * See https://github.com/rvagg/nan for the latest update to this file
+ **********************************************************************************/
+
+#ifndef NAN_H_
+#define NAN_H_
+
+#include <uv.h>
+#include <node.h>
+#include <node_buffer.h>
+#include <node_version.h>
+#include <node_object_wrap.h>
+#include <string.h>
+
+#if defined(__GNUC__) && !defined(DEBUG)
+# define NAN_INLINE inline __attribute__((always_inline))
+#elif defined(_MSC_VER) && !defined(DEBUG)
+# define NAN_INLINE __forceinline
+#else
+# define NAN_INLINE inline
+#endif
+
+#if defined(__GNUC__) && !V8_DISABLE_DEPRECATIONS
+# define NAN_DEPRECATED __attribute__((deprecated))
+#elif defined(_MSC_VER) && !V8_DISABLE_DEPRECATIONS
+# define NAN_DEPRECATED __declspec(deprecated)
+#else
+# define NAN_DEPRECATED
+#endif
+
+// some generic helpers
+
+template<typename T> NAN_INLINE bool NanSetPointerSafe(
+    T *var
+  , T val
+) {
+  if (var) {
+    *var = val;
+    return true;
+  } else {
+    return false;
+  }
+}
+
+template<typename T> NAN_INLINE T NanGetPointerSafe(
+    T *var
+  , T fallback = reinterpret_cast<T>(0)
+) {
+  if (var) {
+    return *var;
+  } else {
+    return fallback;
+  }
+}
+
+NAN_INLINE bool NanBooleanOptionValue(
+    v8::Local<v8::Object> optionsObj
+  , v8::Handle<v8::String> opt, bool def
+) {
+  if (def) {
+    return optionsObj.IsEmpty()
+      || !optionsObj->Has(opt)
+      || optionsObj->Get(opt)->BooleanValue();
+  } else {
+    return !optionsObj.IsEmpty()
+      && optionsObj->Has(opt)
+      && optionsObj->Get(opt)->BooleanValue();
+  }
+}
+
+NAN_INLINE bool NanBooleanOptionValue(
+    v8::Local<v8::Object> optionsObj
+  , v8::Handle<v8::String> opt
+) {
+  return NanBooleanOptionValue(optionsObj, opt, false);
+}
+
+NAN_INLINE uint32_t NanUInt32OptionValue(
+    v8::Local<v8::Object> optionsObj
+  , v8::Handle<v8::String> opt
+  , uint32_t def
+) {
+  return !optionsObj.IsEmpty()
+    && optionsObj->Has(opt)
+    && optionsObj->Get(opt)->IsNumber()
+      ? optionsObj->Get(opt)->Uint32Value()
+      : def;
+}
+
+#if (NODE_MODULE_VERSION > 0x000B)
+// Node 0.11+ (0.11.3 and below won't compile with these)
+
+# define _NAN_METHOD_ARGS_TYPE const v8::FunctionCallbackInfo<v8::Value>&
+# define _NAN_METHOD_ARGS _NAN_METHOD_ARGS_TYPE args
+# define _NAN_METHOD_RETURN_TYPE void
+
+# define _NAN_GETTER_ARGS_TYPE const v8::PropertyCallbackInfo<v8::Value>&
+# define _NAN_GETTER_ARGS _NAN_GETTER_ARGS_TYPE args
+# define _NAN_GETTER_RETURN_TYPE void
+
+# define _NAN_SETTER_ARGS_TYPE const v8::PropertyCallbackInfo<void>&
+# define _NAN_SETTER_ARGS _NAN_SETTER_ARGS_TYPE args
+# define _NAN_SETTER_RETURN_TYPE void
+
+# define _NAN_PROPERTY_GETTER_ARGS_TYPE                                        \
+    const v8::PropertyCallbackInfo<v8::Value>&
+# define _NAN_PROPERTY_GETTER_ARGS _NAN_PROPERTY_GETTER_ARGS_TYPE args
+# define _NAN_PROPERTY_GETTER_RETURN_TYPE void
+
+# define _NAN_PROPERTY_SETTER_ARGS_TYPE                                        \
+    const v8::PropertyCallbackInfo<v8::Value>&
+# define _NAN_PROPERTY_SETTER_ARGS _NAN_PROPERTY_SETTER_ARGS_TYPE args
+# define _NAN_PROPERTY_SETTER_RETURN_TYPE void
+
+# define _NAN_PROPERTY_ENUMERATOR_ARGS_TYPE                                    \
+    const v8::PropertyCallbackInfo<v8::Array>&
+# define _NAN_PROPERTY_ENUMERATOR_ARGS _NAN_PROPERTY_ENUMERATOR_ARGS_TYPE args
+# define _NAN_PROPERTY_ENUMERATOR_RETURN_TYPE void
+
+# define _NAN_PROPERTY_DELETER_ARGS_TYPE                                       \
+    const v8::PropertyCallbackInfo<v8::Boolean>&
+# define _NAN_PROPERTY_DELETER_ARGS                                            \
+    _NAN_PROPERTY_DELETER_ARGS_TYPE args
+# define _NAN_PROPERTY_DELETER_RETURN_TYPE void
+
+# define _NAN_PROPERTY_QUERY_ARGS_TYPE                                         \
+    const v8::PropertyCallbackInfo<v8::Integer>&
+# define _NAN_PROPERTY_QUERY_ARGS _NAN_PROPERTY_QUERY_ARGS_TYPE args
+# define _NAN_PROPERTY_QUERY_RETURN_TYPE void
+
+# define _NAN_INDEX_GETTER_ARGS_TYPE                                           \
+    const v8::PropertyCallbackInfo<v8::Value>&
+# define _NAN_INDEX_GETTER_ARGS _NAN_INDEX_GETTER_ARGS_TYPE args
+# define _NAN_INDEX_GETTER_RETURN_TYPE void
+
+# define _NAN_INDEX_SETTER_ARGS_TYPE                                           \
+    const v8::PropertyCallbackInfo<v8::Value>&
+# define _NAN_INDEX_SETTER_ARGS _NAN_INDEX_SETTER_ARGS_TYPE args
+# define _NAN_INDEX_SETTER_RETURN_TYPE void
+
+# define _NAN_INDEX_ENUMERATOR_ARGS_TYPE                                       \
+    const v8::PropertyCallbackInfo<v8::Array>&
+# define _NAN_INDEX_ENUMERATOR_ARGS _NAN_INDEX_ENUMERATOR_ARGS_TYPE args
+# define _NAN_INDEX_ENUMERATOR_RETURN_TYPE void
+
+# define _NAN_INDEX_DELETER_ARGS_TYPE                                          \
+    const v8::PropertyCallbackInfo<v8::Boolean>&
+# define _NAN_INDEX_DELETER_ARGS _NAN_INDEX_DELETER_ARGS_TYPE args
+# define _NAN_INDEX_DELETER_RETURN_TYPE void
+
+# define _NAN_INDEX_QUERY_ARGS_TYPE                                            \
+    const v8::PropertyCallbackInfo<v8::Integer>&
+# define _NAN_INDEX_QUERY_ARGS _NAN_INDEX_QUERY_ARGS_TYPE args
+# define _NAN_INDEX_QUERY_RETURN_TYPE void
+
+typedef v8::FunctionCallback NanFunctionCallback;
+static v8::Isolate* nan_isolate = v8::Isolate::GetCurrent();
+
+# define NanUndefined() v8::Undefined(nan_isolate)
+# define NanNull() v8::Null(nan_isolate)
+# define NanTrue() v8::True(nan_isolate)
+# define NanFalse() v8::False(nan_isolate)
+# define NanAdjustExternalMemory(amount)                                       \
+    nan_isolate->AdjustAmountOfExternalAllocatedMemory(amount)
+# define NanSetTemplate(templ, name, value) templ->Set(nan_isolate, name, value)
+# define NanGetCurrentContext() nan_isolate->GetCurrentContext()
+# define NanMakeCallback(target, func, argc, argv)                             \
+    node::MakeCallback(nan_isolate, target, func, argc, argv)
+# define NanGetInternalFieldPointer(object, index)                             \
+    object->GetAlignedPointerFromInternalField(index)
+# define NanSetInternalFieldPointer(object, index, value)                      \
+    object->SetAlignedPointerInInternalField(index, value)
+
+  template<typename T>
+  NAN_INLINE v8::Local<T> NanNew() {
+    return T::New(nan_isolate);
+  }
+
+  template<typename T, typename P>
+  NAN_INLINE v8::Local<T> NanNew(P arg1) {
+    return T::New(nan_isolate, arg1);
+  }
+
+  template<typename T>
+  NAN_INLINE v8::Local<v8::Signature> NanNew(
+      v8::Handle<v8::FunctionTemplate> receiver
+    , int argc
+    , v8::Handle<v8::FunctionTemplate> argv[] = 0) {
+    return v8::Signature::New(nan_isolate, receiver, argc, argv);
+  }
+
+  template<typename T>
+  NAN_INLINE v8::Local<v8::FunctionTemplate> NanNew(
+      NanFunctionCallback callback
+    , v8::Handle<v8::Value> data = v8::Handle<v8::Value>()
+    , v8::Handle<v8::Signature> signature = v8::Handle<v8::Signature>()) {
+    return T::New(nan_isolate, callback, data, signature);
+  }
+
+  template<typename T>
+  NAN_INLINE v8::Local<T> NanNew(v8::Handle<T> arg1) {
+    return v8::Local<T>::New(nan_isolate, arg1);
+  }
+
+  template<typename T>
+  NAN_INLINE v8::Local<T> NanNew(const v8::Persistent<T> &arg1) {
+    return v8::Local<T>::New(nan_isolate, arg1);
+  }
+
+  template<typename T, typename P>
+  NAN_INLINE v8::Local<T> NanNew(P arg1, int arg2) {
+    return T::New(nan_isolate, arg1, arg2);
+  }
+
+  template<>
+  NAN_INLINE v8::Local<v8::Array> NanNew<v8::Array>() {
+    return v8::Array::New(nan_isolate);
+  }
+
+  template<>
+  NAN_INLINE v8::Local<v8::Array> NanNew<v8::Array>(int length) {
+    return v8::Array::New(nan_isolate, length);
+  }
+
+  template<>
+  NAN_INLINE v8::Local<v8::Date> NanNew<v8::Date>(double time) {
+    return v8::Date::New(nan_isolate, time).As<v8::Date>();
+  }
+
+  template<>
+  NAN_INLINE v8::Local<v8::Date> NanNew<v8::Date>(int time) {
+    return v8::Date::New(nan_isolate, time).As<v8::Date>();
+  }
+
+  typedef v8::UnboundScript NanUnboundScript;
+  typedef v8::Script NanBoundScript;
+
+  template<typename T, typename P>
+  NAN_INLINE v8::Local<T> NanNew(
+      P s
+    , const v8::ScriptOrigin& origin
+  ) {
+    v8::ScriptCompiler::Source source(s, origin);
+    return v8::ScriptCompiler::CompileUnbound(nan_isolate, &source);
+  }
+
+  template<>
+  NAN_INLINE v8::Local<NanUnboundScript> NanNew<NanUnboundScript>(
+      v8::Local<v8::String> s
+  ) {
+    v8::ScriptCompiler::Source source(s);
+    return v8::ScriptCompiler::CompileUnbound(nan_isolate, &source);
+  }
+
+  NAN_INLINE v8::Local<v8::String> NanNew(
+      v8::String::ExternalStringResource *resource) {
+    return v8::String::NewExternal(nan_isolate, resource);
+  }
+
+  NAN_INLINE v8::Local<v8::String> NanNew(
+      v8::String::ExternalAsciiStringResource *resource) {
+    return v8::String::NewExternal(nan_isolate, resource);
+  }
+
+  template<>
+  NAN_INLINE v8::Local<v8::BooleanObject> NanNew(bool value) {
+    return v8::BooleanObject::New(value).As<v8::BooleanObject>();
+  }
+
+  template<>
+  NAN_INLINE v8::Local<v8::StringObject>
+  NanNew<v8::StringObject, v8::Local<v8::String> >(
+      v8::Local<v8::String> value) {
+    return v8::StringObject::New(value).As<v8::StringObject>();
+  }
+
+  template<>
+  NAN_INLINE v8::Local<v8::StringObject>
+  NanNew<v8::StringObject, v8::Handle<v8::String> >(
+      v8::Handle<v8::String> value) {
+    return v8::StringObject::New(value).As<v8::StringObject>();
+  }
+
+  template<>
+  NAN_INLINE v8::Local<v8::NumberObject> NanNew<v8::NumberObject>(double val) {
+    return v8::NumberObject::New(nan_isolate, val).As<v8::NumberObject>();
+  }
+
+  template<typename T>
+  NAN_INLINE v8::Local<v8::RegExp> NanNew(
+      v8::Handle<v8::String> pattern, v8::RegExp::Flags flags) {
+    return v8::RegExp::New(pattern, flags);
+  }
+
+  template<typename T>
+  NAN_INLINE v8::Local<v8::RegExp> NanNew(
+      v8::Local<v8::String> pattern, v8::RegExp::Flags flags) {
+    return v8::RegExp::New(pattern, flags);
+  }
+
+  template<typename T, typename P>
+  NAN_INLINE v8::Local<v8::RegExp> NanNew(
+      v8::Handle<v8::String> pattern, v8::RegExp::Flags flags) {
+    return v8::RegExp::New(pattern, flags);
+  }
+
+  template<typename T, typename P>
+  NAN_INLINE v8::Local<v8::RegExp> NanNew(
+      v8::Local<v8::String> pattern, v8::RegExp::Flags flags) {
+    return v8::RegExp::New(pattern, flags);
+  }
+
+  template<>
+  NAN_INLINE v8::Local<v8::Uint32> NanNew<v8::Uint32, int32_t>(int32_t val) {
+    return v8::Uint32::NewFromUnsigned(nan_isolate, val)->ToUint32();
+  }
+
+  template<>
+  NAN_INLINE v8::Local<v8::Uint32> NanNew<v8::Uint32, uint32_t>(uint32_t val) {
+    return v8::Uint32::NewFromUnsigned(nan_isolate, val)->ToUint32();
+  }
+
+  template<>
+  NAN_INLINE v8::Local<v8::Int32> NanNew<v8::Int32, int32_t>(int32_t val) {
+    return v8::Int32::New(nan_isolate, val)->ToInt32();
+  }
+
+  template<>
+  NAN_INLINE v8::Local<v8::Int32> NanNew<v8::Int32, uint32_t>(uint32_t val) {
+    return v8::Int32::New(nan_isolate, val)->ToInt32();
+  }
+
+  template<>
+  NAN_INLINE v8::Local<v8::String> NanNew<v8::String, char *>(
+      char *arg
+    , int length) {
+    return v8::String::NewFromUtf8(
+        nan_isolate
+      , arg
+      , v8::String::kNormalString
+      , length);
+  }
+
+  template<>
+  NAN_INLINE v8::Local<v8::String> NanNew<v8::String, const char *>(
+      const char *arg
+    , int length) {
+    return v8::String::NewFromUtf8(
+        nan_isolate
+      , arg
+      , v8::String::kNormalString
+      , length);
+  }
+
+  template<>
+  NAN_INLINE v8::Local<v8::String> NanNew<v8::String, char *>(char *arg) {
+    return v8::String::NewFromUtf8(nan_isolate, arg);
+  }
+
+  template<>
+  NAN_INLINE v8::Local<v8::String> NanNew<v8::String, const char *>(
+      const char *arg) {
+    return v8::String::NewFromUtf8(nan_isolate, arg);
+  }
+
+  template<>
+  NAN_INLINE v8::Local<v8::String> NanNew<v8::String, uint8_t *>(
+      uint8_t *arg
+    , int length) {
+    return v8::String::NewFromOneByte(
+        nan_isolate
+      , arg
+      , v8::String::kNormalString
+      , length);
+  }
+
+  template<>
+  NAN_INLINE v8::Local<v8::String> NanNew<v8::String, const uint8_t *>(
+      const uint8_t *arg
+    , int length) {
+    return v8::String::NewFromOneByte(
+        nan_isolate
+      , arg
+      , v8::String::kNormalString
+      , length);
+  }
+
+  template<>
+  NAN_INLINE v8::Local<v8::String> NanNew<v8::String, uint8_t *>(uint8_t *arg) {
+    return v8::String::NewFromOneByte(nan_isolate, arg);
+  }
+
+  template<>
+  NAN_INLINE v8::Local<v8::String> NanNew<v8::String, const uint8_t *>(
+      const uint8_t *arg) {
+    return v8::String::NewFromOneByte(nan_isolate, arg);
+  }
+
+  template<>
+  NAN_INLINE v8::Local<v8::String> NanNew<v8::String, uint16_t *>(
+      uint16_t *arg
+    , int length) {
+    return v8::String::NewFromTwoByte(
+        nan_isolate
+      , arg
+      , v8::String::kNormalString
+      , length);
+  }
+
+  template<>
+  NAN_INLINE v8::Local<v8::String> NanNew<v8::String, const uint16_t *>(
+      const uint16_t *arg
+    , int length) {
+    return v8::String::NewFromTwoByte(
+        nan_isolate
+      , arg
+      , v8::String::kNormalString
+      , length);
+  }
+  template<>
+  NAN_INLINE v8::Local<v8::String> NanNew<v8::String, uint16_t *>(
+      uint16_t *arg) {
+    return v8::String::NewFromTwoByte(nan_isolate, arg);
+  }
+
+  template<>
+  NAN_INLINE v8::Local<v8::String> NanNew<v8::String, const uint16_t *>(
+      const uint16_t *arg) {
+    return v8::String::NewFromTwoByte(nan_isolate, arg);
+  }
+
+  template<>
+  NAN_INLINE v8::Local<v8::String> NanNew<v8::String>() {
+    return v8::String::Empty(nan_isolate);
+  }
+
+  NAN_INLINE void NanAddGCEpilogueCallback(
+      v8::Isolate::GCEpilogueCallback callback
+    , v8::GCType gc_type_filter = v8::kGCTypeAll) {
+    nan_isolate->AddGCEpilogueCallback(callback, gc_type_filter);
+  }
+
+  NAN_INLINE void NanRemoveGCEpilogueCallback(
+      v8::Isolate::GCEpilogueCallback callback) {
+    nan_isolate->RemoveGCEpilogueCallback(callback);
+  }
+
+  NAN_INLINE void NanAddGCPrologueCallback(
+      v8::Isolate::GCPrologueCallback callback
+    , v8::GCType gc_type_filter = v8::kGCTypeAll) {
+    nan_isolate->AddGCPrologueCallback(callback, gc_type_filter);
+  }
+
+  NAN_INLINE void NanRemoveGCPrologueCallback(
+      v8::Isolate::GCPrologueCallback callback) {
+    nan_isolate->RemoveGCPrologueCallback(callback);
+  }
+
+  NAN_INLINE void NanGetHeapStatistics(
+      v8::HeapStatistics *heap_statistics) {
+    nan_isolate->GetHeapStatistics(heap_statistics);
+  }
+
+# define NanSymbol(value) NanNew<v8::String>(value)
+
+  template<typename T>
+  NAN_INLINE void NanAssignPersistent(
+      v8::Persistent<T>& handle
+    , v8::Handle<T> obj) {
+      handle.Reset(nan_isolate, obj);
+  }
+
+  template<typename T>
+  NAN_INLINE void NanAssignPersistent(
+      v8::Persistent<T>& handle
+    , const v8::Persistent<T>& obj) {
+      handle.Reset(nan_isolate, obj);
+  }
+
+  template<typename T, typename P>
+  struct _NanWeakCallbackInfo {
+    typedef void (*Callback)(
+      const v8::WeakCallbackData<T, _NanWeakCallbackInfo<T, P> >& data);
+    _NanWeakCallbackInfo(v8::Handle<T> handle, P* param, Callback cb)
+      : parameter(param), callback(cb) {
+       NanAssignPersistent(persistent, handle);
+    }
+
+    ~_NanWeakCallbackInfo() {
+      persistent.Reset();
+    }
+
+    P* const parameter;
+    Callback const callback;
+    v8::Persistent<T> persistent;
+  };
+
+  template<typename T, typename P>
+  class _NanWeakCallbackData {
+   public:
+    _NanWeakCallbackData(_NanWeakCallbackInfo<T, P> *info)
+      : info_(info) { }
+
+    NAN_INLINE v8::Local<T> GetValue() const {
+      return NanNew(info_->persistent);
+    }
+    NAN_INLINE P* GetParameter() const { return info_->parameter; }
+    NAN_INLINE void Revive() const {
+      info_->persistent.SetWeak(info_, info_->callback);
+    }
+
+    NAN_INLINE void Dispose() const {
+      delete info_;
+    }
+
+   private:
+    _NanWeakCallbackInfo<T, P>* info_;
+  };
+
+// do not use for declaration
+# define NAN_WEAK_CALLBACK(name)                                               \
+    template<typename T, typename P>                                           \
+    static void name(                                                          \
+      const v8::WeakCallbackData<T, _NanWeakCallbackInfo<T, P> > &data) {      \
+        _NanWeakCallbackData<T, P> wcbd(                                       \
+           data.GetParameter());                                               \
+        _Nan_Weak_Callback_ ## name(wcbd);                                     \
+    }                                                                          \
+                                                                               \
+    template<typename T, typename P>                                           \
+    NAN_INLINE void _Nan_Weak_Callback_ ## name(                               \
+        const _NanWeakCallbackData<T, P> &data)
+
+# define NanScope() v8::HandleScope scope(nan_isolate)
+# define NanEscapableScope() v8::EscapableHandleScope scope(nan_isolate)
+# define NanEscapeScope(val) scope.Escape(val)
+# define NanLocker() v8::Locker locker(nan_isolate)
+# define NanUnlocker() v8::Unlocker unlocker(nan_isolate)
+# define NanReturnValue(value) return args.GetReturnValue().Set(value)
+# define NanReturnUndefined() return
+# define NanReturnNull() return args.GetReturnValue().SetNull()
+# define NanReturnEmptyString() return args.GetReturnValue().SetEmptyString()
+
+# define NanObjectWrapHandle(obj) obj->handle()
+
+template<typename T, typename P>
+void NAN_INLINE NanMakeWeakPersistent(
+    v8::Handle<T> handle
+  , P* parameter
+  , typename _NanWeakCallbackInfo<T, P>::Callback callback) {
+    _NanWeakCallbackInfo<T, P> *cbinfo =
+     new _NanWeakCallbackInfo<T, P>(handle, parameter, callback);
+    cbinfo->persistent.SetWeak(cbinfo, callback);
+}
+
+# define _NAN_ERROR(fun, errmsg) fun(NanNew<v8::String>(errmsg))
+
+# define _NAN_THROW_ERROR(fun, errmsg)                                         \
+    do {                                                                       \
+      NanScope();                                                              \
+      nan_isolate->ThrowException(_NAN_ERROR(fun, errmsg));                    \
+    } while (0);
+
+  NAN_INLINE v8::Local<v8::Value> NanError(const char* errmsg) {
+    return  _NAN_ERROR(v8::Exception::Error, errmsg);
+  }
+
+  NAN_INLINE void NanThrowError(const char* errmsg) {
+    _NAN_THROW_ERROR(v8::Exception::Error, errmsg);
+  }
+
+  NAN_INLINE void NanThrowError(v8::Handle<v8::Value> error) {
+    NanScope();
+    nan_isolate->ThrowException(error);
+  }
+
+  NAN_INLINE v8::Local<v8::Value> NanError(
+      const char *msg
+    , const int errorNumber
+  ) {
+    v8::Local<v8::Value> err = v8::Exception::Error(NanNew<v8::String>(msg));
+    v8::Local<v8::Object> obj = err.As<v8::Object>();
+    obj->Set(NanSymbol("code"), NanNew<v8::Integer>(errorNumber));
+    return err;
+  }
+
+  NAN_INLINE void NanThrowError(
+      const char *msg
+    , const int errorNumber
+  ) {
+    NanThrowError(NanError(msg, errorNumber));
+  }
+
+  NAN_INLINE v8::Local<v8::Value> NanTypeError(const char* errmsg) {
+    return _NAN_ERROR(v8::Exception::TypeError, errmsg);
+  }
+
+  NAN_INLINE void NanThrowTypeError(const char* errmsg) {
+    _NAN_THROW_ERROR(v8::Exception::TypeError, errmsg);
+  }
+
+  NAN_INLINE v8::Local<v8::Value> NanRangeError(const char* errmsg) {
+    return _NAN_ERROR(v8::Exception::RangeError, errmsg);
+  }
+
+  NAN_INLINE void NanThrowRangeError(const char* errmsg) {
+    _NAN_THROW_ERROR(v8::Exception::RangeError, errmsg);
+  }
+
+  template<typename T> NAN_INLINE void NanDisposePersistent(
+      v8::Persistent<T> &handle
+  ) {
+    handle.Reset();
+  }
+
+  NAN_INLINE v8::Local<v8::Object> NanNewBufferHandle (
+      char *data
+    , size_t length
+    , node::smalloc::FreeCallback callback
+    , void *hint
+  ) {
+    return node::Buffer::New(nan_isolate, data, length, callback, hint);
+  }
+
+  NAN_INLINE v8::Local<v8::Object> NanNewBufferHandle (
+      const char *data
+    , uint32_t size
+  ) {
+    return node::Buffer::New(nan_isolate, data, size);
+  }
+
+  NAN_INLINE v8::Local<v8::Object> NanNewBufferHandle (uint32_t size) {
+    return node::Buffer::New(nan_isolate, size);
+  }
+
+  NAN_INLINE v8::Local<v8::Object> NanBufferUse(
+      char* data
+    , uint32_t size
+  ) {
+    return node::Buffer::Use(nan_isolate, data, size);
+  }
+
+  NAN_INLINE bool NanHasInstance(
+      v8::Persistent<v8::FunctionTemplate>& function_template
+    , v8::Handle<v8::Value> value
+  ) {
+    return NanNew(function_template)->HasInstance(value);
+  }
+
+  NAN_INLINE v8::Local<v8::Context> NanNewContextHandle(
+      v8::ExtensionConfiguration* extensions = NULL
+    , v8::Handle<v8::ObjectTemplate> tmpl = v8::Handle<v8::ObjectTemplate>()
+    , v8::Handle<v8::Value> obj = v8::Handle<v8::Value>()
+  ) {
+    return v8::Local<v8::Context>::New(
+        nan_isolate
+      , v8::Context::New(nan_isolate, extensions, tmpl, obj)
+    );
+  }
+
+  NAN_INLINE v8::Local<NanBoundScript> NanCompileScript(
+      v8::Local<v8::String> s
+    , const v8::ScriptOrigin& origin
+  ) {
+    v8::ScriptCompiler::Source source(s, origin);
+    return v8::ScriptCompiler::Compile(nan_isolate, &source);
+  }
+
+  NAN_INLINE v8::Local<NanBoundScript> NanCompileScript(
+      v8::Local<v8::String> s
+  ) {
+    v8::ScriptCompiler::Source source(s);
+    return v8::ScriptCompiler::Compile(nan_isolate, &source);
+  }
+
+  NAN_INLINE v8::Local<v8::Value> NanRunScript(
+      v8::Local<NanUnboundScript> script
+  ) {
+    return script->BindToCurrentContext()->Run();
+  }
+
+  NAN_INLINE v8::Local<v8::Value> NanRunScript(
+      v8::Local<NanBoundScript> script
+  ) {
+    return script->Run();
+  }
+
+#else
+// Node 0.8 and 0.10
+
+# define _NAN_METHOD_ARGS_TYPE const v8::Arguments&
+# define _NAN_METHOD_ARGS _NAN_METHOD_ARGS_TYPE args
+# define _NAN_METHOD_RETURN_TYPE v8::Handle<v8::Value>
+
+# define _NAN_GETTER_ARGS_TYPE const v8::AccessorInfo &
+# define _NAN_GETTER_ARGS _NAN_GETTER_ARGS_TYPE args
+# define _NAN_GETTER_RETURN_TYPE v8::Handle<v8::Value>
+
+# define _NAN_SETTER_ARGS_TYPE const v8::AccessorInfo &
+# define _NAN_SETTER_ARGS _NAN_SETTER_ARGS_TYPE args
+# define _NAN_SETTER_RETURN_TYPE void
+
+# define _NAN_PROPERTY_GETTER_ARGS_TYPE const v8::AccessorInfo&
+# define _NAN_PROPERTY_GETTER_ARGS _NAN_PROPERTY_GETTER_ARGS_TYPE args
+# define _NAN_PROPERTY_GETTER_RETURN_TYPE v8::Handle<v8::Value>
+
+# define _NAN_PROPERTY_SETTER_ARGS_TYPE const v8::AccessorInfo&
+# define _NAN_PROPERTY_SETTER_ARGS _NAN_PROPERTY_SETTER_ARGS_TYPE args
+# define _NAN_PROPERTY_SETTER_RETURN_TYPE v8::Handle<v8::Value>
+
+# define _NAN_PROPERTY_ENUMERATOR_ARGS_TYPE const v8::AccessorInfo&
+# define _NAN_PROPERTY_ENUMERATOR_ARGS _NAN_PROPERTY_ENUMERATOR_ARGS_TYPE args
+# define _NAN_PROPERTY_ENUMERATOR_RETURN_TYPE v8::Handle<v8::Array>
+
+# define _NAN_PROPERTY_DELETER_ARGS_TYPE const v8::AccessorInfo&
+# define _NAN_PROPERTY_DELETER_ARGS _NAN_PROPERTY_DELETER_ARGS_TYPE args
+# define _NAN_PROPERTY_DELETER_RETURN_TYPE v8::Handle<v8::Boolean>
+
+# define _NAN_PROPERTY_QUERY_ARGS_TYPE const v8::AccessorInfo&
+# define _NAN_PROPERTY_QUERY_ARGS _NAN_PROPERTY_QUERY_ARGS_TYPE args
+# define _NAN_PROPERTY_QUERY_RETURN_TYPE v8::Handle<v8::Integer>
+
+# define _NAN_INDEX_GETTER_ARGS_TYPE const v8::AccessorInfo&
+# define _NAN_INDEX_GETTER_ARGS _NAN_INDEX_GETTER_ARGS_TYPE args
+# define _NAN_INDEX_GETTER_RETURN_TYPE v8::Handle<v8::Value>
+
+# define _NAN_INDEX_SETTER_ARGS_TYPE const v8::AccessorInfo&
+# define _NAN_INDEX_SETTER_ARGS _NAN_INDEX_SETTER_ARGS_TYPE args
+# define _NAN_INDEX_SETTER_RETURN_TYPE v8::Handle<v8::Value>
+
+# define _NAN_INDEX_ENUMERATOR_ARGS_TYPE const v8::AccessorInfo&
+# define _NAN_INDEX_ENUMERATOR_ARGS _NAN_INDEX_ENUMERATOR_ARGS_TYPE args
+# define _NAN_INDEX_ENUMERATOR_RETURN_TYPE v8::Handle<v8::Array>
+
+# define _NAN_INDEX_DELETER_ARGS_TYPE const v8::AccessorInfo&
+# define _NAN_INDEX_DELETER_ARGS _NAN_INDEX_DELETER_ARGS_TYPE args
+# define _NAN_INDEX_DELETER_RETURN_TYPE v8::Handle<v8::Boolean>
+
+# define _NAN_INDEX_QUERY_ARGS_TYPE const v8::AccessorInfo&
+# define _NAN_INDEX_QUERY_ARGS _NAN_INDEX_QUERY_ARGS_TYPE args
+# define _NAN_INDEX_QUERY_RETURN_TYPE v8::Handle<v8::Integer>
+
+typedef v8::InvocationCallback NanFunctionCallback;
+
+# define NanUndefined() v8::Undefined()
+# define NanNull() v8::Null()
+# define NanTrue() v8::True()
+# define NanFalse() v8::False()
+# define NanAdjustExternalMemory(amount)                                       \
+    v8::V8::AdjustAmountOfExternalAllocatedMemory(amount)
+# define NanSetTemplate(templ, name, value) templ->Set(name, value)
+# define NanGetCurrentContext() v8::Context::GetCurrent()
+# if NODE_VERSION_AT_LEAST(0, 8, 0)
+#  define NanMakeCallback(target, func, argc, argv)                            \
+    node::MakeCallback(target, func, argc, argv)
+# else
+#  define NanMakeCallback(target, func, argc, argv)                            \
+    do {                                                                       \
+      v8::TryCatch try_catch;                                                  \
+      func->Call(target, argc, argv);                                          \
+      if (try_catch.HasCaught()) {                                             \
+          v8::FatalException(try_catch);                                       \
+      }                                                                        \
+    } while (0)
+# endif
+
+# define NanSymbol(value) v8::String::NewSymbol(value)
+
+  template<typename T>
+  NAN_INLINE v8::Local<T> NanNew() {
+    return v8::Local<T>::New(T::New());
+  }
+
+  template<typename T>
+  NAN_INLINE v8::Local<T> NanNew(v8::Handle<T> arg) {
+    return v8::Local<T>::New(arg);
+  }
+
+  template<typename T>
+  NAN_INLINE v8::Local<v8::Signature> NanNew(
+      v8::Handle<v8::FunctionTemplate> receiver
+    , int argc
+    , v8::Handle<v8::FunctionTemplate> argv[] = 0) {
+    return v8::Signature::New(receiver, argc, argv);
+  }
+
+  template<typename T>
+  NAN_INLINE v8::Local<v8::FunctionTemplate> NanNew(
+      NanFunctionCallback callback
+    , v8::Handle<v8::Value> data = v8::Handle<v8::Value>()
+    , v8::Handle<v8::Signature> signature = v8::Handle<v8::Signature>()) {
+    return T::New(callback, data, signature);
+  }
+
+  template<typename T>
+  NAN_INLINE v8::Local<T> NanNew(const v8::Persistent<T> &arg) {
+    return v8::Local<T>::New(arg);
+  }
+
+  template<typename T, typename P>
+  NAN_INLINE v8::Local<T> NanNew(P arg) {
+    return v8::Local<T>::New(T::New(arg));
+  }
+
+  template<typename T, typename P>
+  NAN_INLINE v8::Local<T> NanNew(P arg, int length) {
+    return v8::Local<T>::New(T::New(arg, length));
+  }
+
+  template<typename T>
+  NAN_INLINE v8::Local<v8::RegExp> NanNew(
+      v8::Handle<v8::String> pattern, v8::RegExp::Flags flags) {
+    return v8::RegExp::New(pattern, flags);
+  }
+
+  template<typename T>
+  NAN_INLINE v8::Local<v8::RegExp> NanNew(
+      v8::Local<v8::String> pattern, v8::RegExp::Flags flags) {
+    return v8::RegExp::New(pattern, flags);
+  }
+
+  template<typename T, typename P>
+  NAN_INLINE v8::Local<v8::RegExp> NanNew(
+      v8::Handle<v8::String> pattern, v8::RegExp::Flags flags) {
+    return v8::RegExp::New(pattern, flags);
+  }
+
+  template<typename T, typename P>
+  NAN_INLINE v8::Local<v8::RegExp> NanNew(
+      v8::Local<v8::String> pattern, v8::RegExp::Flags flags) {
+    return v8::RegExp::New(pattern, flags);
+  }
+
+  template<>
+  NAN_INLINE v8::Local<v8::Array> NanNew<v8::Array>() {
+    return v8::Array::New();
+  }
+
+  template<>
+  NAN_INLINE v8::Local<v8::Array> NanNew<v8::Array>(int length) {
+    return v8::Array::New(length);
+  }
+
+
+  template<>
+  NAN_INLINE v8::Local<v8::Date> NanNew<v8::Date>(double time) {
+    return v8::Date::New(time).As<v8::Date>();
+  }
+
+  template<>
+  NAN_INLINE v8::Local<v8::Date> NanNew<v8::Date>(int time) {
+    return v8::Date::New(time).As<v8::Date>();
+  }
+
+  typedef v8::Script NanUnboundScript;
+  typedef v8::Script NanBoundScript;
+
+  template<typename T, typename P>
+  NAN_INLINE v8::Local<T> NanNew(
+      P s
+    , const v8::ScriptOrigin& origin
+  ) {
+    return v8::Script::New(s, const_cast<v8::ScriptOrigin *>(&origin));
+  }
+
+  template<>
+  NAN_INLINE v8::Local<NanUnboundScript> NanNew<NanUnboundScript>(
+      v8::Local<v8::String> s
+  ) {
+    return v8::Script::New(s);
+  }
+
+  NAN_INLINE v8::Local<v8::String> NanNew(
+      v8::String::ExternalStringResource *resource) {
+    return v8::String::NewExternal(resource);
+  }
+
+  NAN_INLINE v8::Local<v8::String> NanNew(
+      v8::String::ExternalAsciiStringResource *resource) {
+    return v8::String::NewExternal(resource);
+  }
+
+  template<>
+  NAN_INLINE v8::Local<v8::BooleanObject> NanNew(bool value) {
+    return v8::BooleanObject::New(value).As<v8::BooleanObject>();
+  }
+
+  template<>
+  NAN_INLINE v8::Local<v8::StringObject>
+  NanNew<v8::StringObject, v8::Local<v8::String> >(
+      v8::Local<v8::String> value) {
+    return v8::StringObject::New(value).As<v8::StringObject>();
+  }
+
+  template<>
+  NAN_INLINE v8::Local<v8::StringObject>
+  NanNew<v8::StringObject, v8::Handle<v8::String> >(
+      v8::Handle<v8::String> value) {
+    return v8::StringObject::New(value).As<v8::StringObject>();
+  }
+
+  template<>
+  NAN_INLINE v8::Local<v8::NumberObject> NanNew<v8::NumberObject>(double val) {
+    return v8::NumberObject::New(val).As<v8::NumberObject>();
+  }
+
+  template<>
+  NAN_INLINE v8::Local<v8::Uint32> NanNew<v8::Uint32, int32_t>(int32_t val) {
+    return v8::Uint32::NewFromUnsigned(val)->ToUint32();
+  }
+
+  template<>
+  NAN_INLINE v8::Local<v8::Uint32> NanNew<v8::Uint32, uint32_t>(uint32_t val) {
+    return v8::Uint32::NewFromUnsigned(val)->ToUint32();
+  }
+
+  template<>
+  NAN_INLINE v8::Local<v8::Int32> NanNew<v8::Int32, int32_t>(int32_t val) {
+    return v8::Int32::New(val)->ToInt32();
+  }
+
+  template<>
+  NAN_INLINE v8::Local<v8::Int32> NanNew<v8::Int32, uint32_t>(uint32_t val) {
+    return v8::Int32::New(val)->ToInt32();
+  }
+
+  template<>
+  NAN_INLINE v8::Local<v8::String> NanNew<v8::String, uint8_t *>(
+      uint8_t *arg
+    , int length) {
+    uint16_t *warg = new uint16_t[length];
+    for (int i = 0; i < length; i++) {
+      warg[i] = arg[i];
+    }
+    v8::Local<v8::String> retval = v8::String::New(warg, length);
+    delete[] warg;
+    return retval;
+  }
+
+  template<>
+  NAN_INLINE v8::Local<v8::String> NanNew<v8::String, const uint8_t *>(
+      const uint8_t *arg
+    , int length) {
+    uint16_t *warg = new uint16_t[length];
+    for (int i = 0; i < length; i++) {
+      warg[i] = arg[i];
+    }
+    v8::Local<v8::String> retval = v8::String::New(warg, length);
+    delete[] warg;
+    return retval;
+  }
+
+  template<>
+  NAN_INLINE v8::Local<v8::String> NanNew<v8::String, uint8_t *>(uint8_t *arg) {
+    int length = strlen(reinterpret_cast<char *>(arg));
+    uint16_t *warg = new uint16_t[length];
+    for (int i = 0; i < length; i++) {
+      warg[i] = arg[i];
+    }
+
+    v8::Local<v8::String> retval = v8::String::New(warg, length);
+    delete[] warg;
+    return retval;
+  }
+
+  template<>
+  NAN_INLINE v8::Local<v8::String> NanNew<v8::String, const uint8_t *>(
+      const uint8_t *arg) {
+    int length = strlen(reinterpret_cast<const char *>(arg));
+    uint16_t *warg = new uint16_t[length];
+    for (int i = 0; i < length; i++) {
+      warg[i] = arg[i];
+    }
+    v8::Local<v8::String> retval = v8::String::New(warg, length);
+    delete[] warg;
+    return retval;
+  }
+
+  template<>
+  NAN_INLINE v8::Local<v8::String> NanNew<v8::String>() {
+    return v8::String::Empty();
+  }
+
+  NAN_INLINE void NanAddGCEpilogueCallback(
+    v8::GCEpilogueCallback callback
+  , v8::GCType gc_type_filter = v8::kGCTypeAll) {
+    v8::V8::AddGCEpilogueCallback(callback, gc_type_filter);
+  }
+  NAN_INLINE void NanRemoveGCEpilogueCallback(
+    v8::GCEpilogueCallback callback) {
+    v8::V8::RemoveGCEpilogueCallback(callback);
+  }
+  NAN_INLINE void NanAddGCPrologueCallback(
+    v8::GCPrologueCallback callback
+  , v8::GCType gc_type_filter = v8::kGCTypeAll) {
+    v8::V8::AddGCPrologueCallback(callback, gc_type_filter);
+  }
+  NAN_INLINE void NanRemoveGCPrologueCallback(
+    v8::GCPrologueCallback callback) {
+    v8::V8::RemoveGCPrologueCallback(callback);
+  }
+  NAN_INLINE void NanGetHeapStatistics(
+    v8::HeapStatistics *heap_statistics) {
+    v8::V8::GetHeapStatistics(heap_statistics);
+  }
+
+  template<typename T>
+  NAN_INLINE void NanAssignPersistent(
+      v8::Persistent<T>& handle
+    , v8::Handle<T> obj) {
+      handle.Dispose();
+      handle = v8::Persistent<T>::New(obj);
+  }
+
+  template<typename T, typename P>
+  struct _NanWeakCallbackInfo {
+    typedef void (*Callback)(v8::Persistent<v8::Value> object, void* parameter);
+    _NanWeakCallbackInfo(v8::Handle<T> handle, P* param, Callback cb) :
+        parameter(param)
+      , callback(cb)
+      , persistent(v8::Persistent<T>::New(handle)) { }
+
+    ~_NanWeakCallbackInfo() {
+      persistent.Dispose();
+      persistent.Clear();
+    }
+
+    P* const parameter;
+    Callback const callback;
+    v8::Persistent<T> persistent;
+  };
+
+  template<typename T, typename P>
+  class _NanWeakCallbackData {
+   public:
+    _NanWeakCallbackData(_NanWeakCallbackInfo<T, P> *info)
+      : info_(info) { }
+
+    NAN_INLINE v8::Local<T> GetValue() const {
+      return NanNew(info_->persistent);
+    }
+    NAN_INLINE P* GetParameter() const { return info_->parameter; }
+    NAN_INLINE void Revive() const {
+      info_->persistent.MakeWeak(info_, info_->callback);
+    }
+    NAN_INLINE void Dispose() const {
+      delete info_;
+    }
+
+   private:
+    _NanWeakCallbackInfo<T, P>* info_;
+  };
+
+# define NanGetInternalFieldPointer(object, index)                             \
+    object->GetPointerFromInternalField(index)
+# define NanSetInternalFieldPointer(object, index, value)                      \
+    object->SetPointerInInternalField(index, value)
+
+// do not use for declaration
+# define NAN_WEAK_CALLBACK(name)                                               \
+    template<typename T, typename P>                                           \
+    static void name(                                                          \
+      v8::Persistent<v8::Value> object, void *data) {                          \
+        _NanWeakCallbackData<T, P> wcbd(                                       \
+           static_cast<_NanWeakCallbackInfo<T, P>*>(data));                    \
+        _Nan_Weak_Callback_ ## name(wcbd);                                     \
+    }                                                                          \
+                                                                               \
+    template<typename T, typename P>                                           \
+    NAN_INLINE void _Nan_Weak_Callback_ ## name(                               \
+        const _NanWeakCallbackData<T, P> &data)
+
+  template<typename T, typename P>
+  NAN_INLINE void NanMakeWeakPersistent(
+    v8::Handle<T> handle
+  , P* parameter
+  , typename _NanWeakCallbackInfo<T, P>::Callback callback) {
+      _NanWeakCallbackInfo<T, P> *cbinfo =
+        new _NanWeakCallbackInfo<T, P>(handle, parameter, callback);
+      cbinfo->persistent.MakeWeak(cbinfo, callback);
+  }
+
+# define NanScope() v8::HandleScope scope
+# define NanEscapableScope() v8::HandleScope scope
+# define NanEscapeScope(val) scope.Close(val)
+# define NanLocker() v8::Locker locker
+# define NanUnlocker() v8::Unlocker unlocker
+# define NanReturnValue(value) return scope.Close(value)
+# define NanReturnUndefined() return v8::Undefined()
+# define NanReturnNull() return v8::Null()
+# define NanReturnEmptyString() return v8::String::Empty()
+# define NanObjectWrapHandle(obj) v8::Local<v8::Object>::New(obj->handle_)
+
+# define _NAN_ERROR(fun, errmsg)                                               \
+    fun(v8::String::New(errmsg))
+
+# define _NAN_THROW_ERROR(fun, errmsg)                                         \
+    do {                                                                       \
+      NanScope();                                                              \
+      return v8::Local<v8::Value>::New(                                        \
+        v8::ThrowException(_NAN_ERROR(fun, errmsg)));                          \
+    } while (0);
+
+  NAN_INLINE v8::Local<v8::Value> NanError(const char* errmsg) {
+    return _NAN_ERROR(v8::Exception::Error, errmsg);
+  }
+
+  NAN_INLINE v8::Local<v8::Value> NanThrowError(const char* errmsg) {
+    _NAN_THROW_ERROR(v8::Exception::Error, errmsg);
+  }
+
+  NAN_INLINE v8::Local<v8::Value> NanThrowError(
+      v8::Handle<v8::Value> error
+  ) {
+    NanScope();
+    return v8::Local<v8::Value>::New(v8::ThrowException(error));
+  }
+
+  NAN_INLINE v8::Local<v8::Value> NanError(
+      const char *msg
+    , const int errorNumber
+  ) {
+    v8::Local<v8::Value> err = v8::Exception::Error(v8::String::New(msg));
+    v8::Local<v8::Object> obj = err.As<v8::Object>();
+    obj->Set(v8::String::New("code"), v8::Int32::New(errorNumber));
+    return err;
+  }
+
+  NAN_INLINE v8::Local<v8::Value> NanThrowError(
+      const char *msg
+    , const int errorNumber
+  ) {
+    return NanThrowError(NanError(msg, errorNumber));
+  }
+
+  NAN_INLINE v8::Local<v8::Value> NanTypeError(const char* errmsg) {
+    return _NAN_ERROR(v8::Exception::TypeError, errmsg);
+  }
+
+  NAN_INLINE v8::Local<v8::Value> NanThrowTypeError(
+      const char* errmsg
+  ) {
+    _NAN_THROW_ERROR(v8::Exception::TypeError, errmsg);
+  }
+
+  NAN_INLINE v8::Local<v8::Value> NanRangeError(
+      const char* errmsg
+  ) {
+    return _NAN_ERROR(v8::Exception::RangeError, errmsg);
+  }
+
+  NAN_INLINE v8::Local<v8::Value> NanThrowRangeError(
+      const char* errmsg
+  ) {
+    _NAN_THROW_ERROR(v8::Exception::RangeError, errmsg);
+  }
+
+  template<typename T>
+  NAN_INLINE void NanDisposePersistent(
+      v8::Persistent<T> &handle) {  // NOLINT(runtime/references)
+    handle.Dispose();
+    handle.Clear();
+  }
+
+  NAN_INLINE v8::Local<v8::Object> NanNewBufferHandle (
+      char *data
+    , size_t length
+    , node::Buffer::free_callback callback
+    , void *hint
+  ) {
+    return NanNew<v8::Object>(
+        node::Buffer::New(data, length, callback, hint)->handle_);
+  }
+
+  NAN_INLINE v8::Local<v8::Object> NanNewBufferHandle (
+      const char *data
+    , uint32_t size
+  ) {
+#if NODE_MODULE_VERSION >= 0x000B
+    return NanNew<v8::Object>(node::Buffer::New(data, size)->handle_);
+#else
+    return NanNew<v8::Object>(
+      node::Buffer::New(const_cast<char*>(data), size)->handle_);
+#endif
+  }
+
+  NAN_INLINE v8::Local<v8::Object> NanNewBufferHandle (uint32_t size) {
+    return NanNew<v8::Object>(node::Buffer::New(size)->handle_);
+  }
+
+  NAN_INLINE void FreeData(char *data, void *hint) {
+    delete[] data;
+  }
+
+  NAN_INLINE v8::Local<v8::Object> NanBufferUse(
+      char* data
+    , uint32_t size
+  ) {
+    return NanNew<v8::Object>(
+        node::Buffer::New(data, size, FreeData, NULL)->handle_);
+  }
+
+  NAN_INLINE bool NanHasInstance(
+      v8::Persistent<v8::FunctionTemplate>& function_template
+    , v8::Handle<v8::Value> value
+  ) {
+    return function_template->HasInstance(value);
+  }
+
+  NAN_INLINE v8::Local<v8::Context> NanNewContextHandle(
+      v8::ExtensionConfiguration* extensions = NULL
+    , v8::Handle<v8::ObjectTemplate> tmpl = v8::Handle<v8::ObjectTemplate>()
+    , v8::Handle<v8::Value> obj = v8::Handle<v8::Value>()
+  ) {
+    v8::Persistent<v8::Context> ctx = v8::Context::New(extensions, tmpl, obj);
+    v8::Local<v8::Context> lctx = NanNew<v8::Context>(ctx);
+    ctx.Dispose();
+    return lctx;
+  }
+
+  NAN_INLINE v8::Local<NanBoundScript> NanCompileScript(
+      v8::Local<v8::String> s
+    , const v8::ScriptOrigin& origin
+  ) {
+    return v8::Script::Compile(s, const_cast<v8::ScriptOrigin *>(&origin));
+  }
+
+  NAN_INLINE v8::Local<NanBoundScript> NanCompileScript(
+    v8::Local<v8::String> s
+  ) {
+    return v8::Script::Compile(s);
+  }
+
+  NAN_INLINE v8::Local<v8::Value> NanRunScript(v8::Local<v8::Script> script) {
+    return script->Run();
+  }
+
+#endif  // NODE_MODULE_VERSION
+
+typedef void (*NanFreeCallback)(char *data, void *hint);
+
+#define NAN_METHOD(name) _NAN_METHOD_RETURN_TYPE name(_NAN_METHOD_ARGS)
+#define NAN_GETTER(name)                                                       \
+    _NAN_GETTER_RETURN_TYPE name(                                              \
+        v8::Local<v8::String> property                                         \
+      , _NAN_GETTER_ARGS)
+#define NAN_SETTER(name)                                                       \
+    _NAN_SETTER_RETURN_TYPE name(                                              \
+        v8::Local<v8::String> property                                         \
+      , v8::Local<v8::Value> value                                             \
+      , _NAN_SETTER_ARGS)
+#define NAN_PROPERTY_GETTER(name)                                              \
+    _NAN_PROPERTY_GETTER_RETURN_TYPE name(                                     \
+        v8::Local<v8::String> property                                         \
+      , _NAN_PROPERTY_GETTER_ARGS)
+#define NAN_PROPERTY_SETTER(name)                                              \
+    _NAN_PROPERTY_SETTER_RETURN_TYPE name(                                     \
+        v8::Local<v8::String> property                                         \
+      , v8::Local<v8::Value> value                                             \
+      , _NAN_PROPERTY_SETTER_ARGS)
+#define NAN_PROPERTY_ENUMERATOR(name)                                          \
+    _NAN_PROPERTY_ENUMERATOR_RETURN_TYPE name(_NAN_PROPERTY_ENUMERATOR_ARGS)
+#define NAN_PROPERTY_DELETER(name)                                             \
+    _NAN_PROPERTY_DELETER_RETURN_TYPE name(                                    \
+        v8::Local<v8::String> property                                         \
+      , _NAN_PROPERTY_DELETER_ARGS)
+#define NAN_PROPERTY_QUERY(name)                                               \
+    _NAN_PROPERTY_QUERY_RETURN_TYPE name(                                      \
+        v8::Local<v8::String> property                                         \
+      , _NAN_PROPERTY_QUERY_ARGS)
+# define NAN_INDEX_GETTER(name)                                                \
+    _NAN_INDEX_GETTER_RETURN_TYPE name(uint32_t index, _NAN_INDEX_GETTER_ARGS)
+#define NAN_INDEX_SETTER(name)                                                 \
+    _NAN_INDEX_SETTER_RETURN_TYPE name(                                        \
+        uint32_t index                                                         \
+      , v8::Local<v8::Value> value                                             \
+      , _NAN_INDEX_SETTER_ARGS)
+#define NAN_INDEX_ENUMERATOR(name)                                             \
+    _NAN_INDEX_ENUMERATOR_RETURN_TYPE name(_NAN_INDEX_ENUMERATOR_ARGS)
+#define NAN_INDEX_DELETER(name)                                                \
+    _NAN_INDEX_DELETER_RETURN_TYPE name(                                       \
+        uint32_t index                                                         \
+      , _NAN_INDEX_DELETER_ARGS)
+#define NAN_INDEX_QUERY(name)                                                  \
+    _NAN_INDEX_QUERY_RETURN_TYPE name(uint32_t index, _NAN_INDEX_QUERY_ARGS)
+
+class NanCallback {
+ public:
+  NanCallback() {
+    NanScope();
+    v8::Local<v8::Object> obj = NanNew<v8::Object>();
+    NanAssignPersistent(handle, obj);
+  }
+
+  explicit NanCallback(const v8::Handle<v8::Function> &fn) {
+    NanScope();
+    v8::Local<v8::Object> obj = NanNew<v8::Object>();
+    NanAssignPersistent(handle, obj);
+    SetFunction(fn);
+  }
+
+  ~NanCallback() {
+    if (handle.IsEmpty()) return;
+    NanDisposePersistent(handle);
+  }
+
+  NAN_INLINE void SetFunction(const v8::Handle<v8::Function> &fn) {
+    NanScope();
+    NanNew(handle)->Set(NanSymbol("callback"), fn);
+  }
+
+  NAN_INLINE v8::Local<v8::Function> GetFunction () {
+    return NanNew(handle)->Get(NanSymbol("callback"))
+        .As<v8::Function>();
+  }
+
+  void Call(int argc, v8::Handle<v8::Value> argv[]) {
+    NanScope();
+#if (NODE_MODULE_VERSION > 0x000B)  // 0.11.12+
+    v8::Local<v8::Function> callback = NanNew(handle)->
+        Get(NanSymbol("callback")).As<v8::Function>();
+    node::MakeCallback(
+        nan_isolate
+      , nan_isolate->GetCurrentContext()->Global()
+      , callback
+      , argc
+      , argv
+    );
+#else
+#if NODE_VERSION_AT_LEAST(0, 8, 0)
+    v8::Local<v8::Function> callback = NanNew(handle)->
+        Get(NanSymbol("callback")).As<v8::Function>();
+    node::MakeCallback(
+        v8::Context::GetCurrent()->Global()
+      , callback
+      , argc
+      , argv
+    );
+#else
+    node::MakeCallback(handle, "callback", argc, argv);
+#endif
+#endif
+  }
+
+ private:
+  v8::Persistent<v8::Object> handle;
+};
+
+/* abstract */ class NanAsyncWorker {
+ public:
+  explicit NanAsyncWorker(NanCallback *callback) : callback(callback) {
+    request.data = this;
+    errmsg = NULL;
+
+    NanScope();
+    v8::Local<v8::Object> obj = NanNew<v8::Object>();
+    NanAssignPersistent(persistentHandle, obj);
+  }
+
+  virtual ~NanAsyncWorker() {
+    NanScope();
+
+    if (!persistentHandle.IsEmpty())
+      NanDisposePersistent(persistentHandle);
+    if (callback)
+      delete callback;
+    if (errmsg)
+      delete errmsg;
+  }
+
+  virtual void WorkComplete() {
+    NanScope();
+
+    if (errmsg == NULL)
+      HandleOKCallback();
+    else
+      HandleErrorCallback();
+    delete callback;
+    callback = NULL;
+  }
+
+  NAN_INLINE void SaveToPersistent(const char *key, v8::Local<v8::Object> &obj) {
+    v8::Local<v8::Object> handle = NanNew(persistentHandle);
+    handle->Set(NanSymbol(key), obj);
+  }
+
+  v8::Local<v8::Object> GetFromPersistent(const char *key) {
+    NanEscapableScope();
+    v8::Local<v8::Object> handle = NanNew(persistentHandle);
+    return NanEscapeScope(handle->Get(NanSymbol(key)).As<v8::Object>());
+  }
+
+  virtual void Execute() = 0;
+
+  uv_work_t request;
+
+ protected:
+  v8::Persistent<v8::Object> persistentHandle;
+  NanCallback *callback;
+  const char *errmsg;
+
+  virtual void HandleOKCallback() {
+    NanScope();
+
+    callback->Call(0, NULL);
+  }
+
+  virtual void HandleErrorCallback() {
+    NanScope();
+
+    v8::Local<v8::Value> argv[] = {
+        v8::Exception::Error(NanNew<v8::String>(errmsg))
+    };
+    callback->Call(1, argv);
+  }
+};
+
+NAN_INLINE void NanAsyncExecute (uv_work_t* req) {
+  NanAsyncWorker *worker = static_cast<NanAsyncWorker*>(req->data);
+  worker->Execute();
+}
+
+NAN_INLINE void NanAsyncExecuteComplete (uv_work_t* req) {
+  NanAsyncWorker* worker = static_cast<NanAsyncWorker*>(req->data);
+  worker->WorkComplete();
+  delete worker;
+}
+
+NAN_INLINE void NanAsyncQueueWorker (NanAsyncWorker* worker) {
+  uv_queue_work(
+      uv_default_loop()
+    , &worker->request
+    , NanAsyncExecute
+    , (uv_after_work_cb)NanAsyncExecuteComplete
+  );
+}
+
+//// Base 64 ////
+
+#define _nan_base64_encoded_size(size) ((size + 2 - ((size + 2) % 3)) / 3 * 4)
+
+// Doesn't check for padding at the end.  Can be 1-2 bytes over.
+NAN_INLINE size_t _nan_base64_decoded_size_fast(size_t size) {
+  size_t remainder = size % 4;
+
+  size = (size / 4) * 3;
+  if (remainder) {
+    if (size == 0 && remainder == 1) {
+      // special case: 1-byte input cannot be decoded
+      size = 0;
+    } else {
+      // non-padded input, add 1 or 2 extra bytes
+      size += 1 + (remainder == 3);
+    }
+  }
+
+  return size;
+}
+
+template<typename T>
+NAN_INLINE size_t _nan_base64_decoded_size(
+    const T* src
+  , size_t size
+) {
+  if (size == 0)
+    return 0;
+
+  if (src[size - 1] == '=')
+    size--;
+  if (size > 0 && src[size - 1] == '=')
+    size--;
+
+  return _nan_base64_decoded_size_fast(size);
+}
+
+// supports regular and URL-safe base64
+static const int _nan_unbase64_table[] = {
+    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -2, -1, -1, -2, -1, -1
+  , -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1
+  , -2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 62, -1, 62, -1, 63
+  , 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, -1, -1, -1, -1, -1, -1
+  , -1,  0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14
+  , 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -1, -1, -1, -1, 63
+  , -1, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40
+  , 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, -1, -1, -1, -1, -1
+  , -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1
+  , -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1
+  , -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1
+  , -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1
+  , -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1
+  , -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1
+  , -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1
+  , -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1
+};
+
+#define _nan_unbase64(x) _nan_unbase64_table[(uint8_t)(x)]
+
+template<typename T> static size_t _nan_base64_decode(
+    char* buf
+  , size_t len
+  , const T* src
+  , const size_t srcLen
+) {
+  char* dst = buf;
+  char* dstEnd = buf + len;
+  const T* srcEnd = src + srcLen;
+
+  while (src < srcEnd && dst < dstEnd) {
+    ptrdiff_t remaining = srcEnd - src;
+    char a, b, c, d;
+
+    while (_nan_unbase64(*src) < 0 && src < srcEnd) src++, remaining--;
+    if (remaining == 0 || *src == '=') break;
+    a = _nan_unbase64(*src++);
+
+    while (_nan_unbase64(*src) < 0 && src < srcEnd) src++, remaining--;
+    if (remaining <= 1 || *src == '=') break;
+    b = _nan_unbase64(*src++);
+
+    *dst++ = (a << 2) | ((b & 0x30) >> 4);
+    if (dst == dstEnd) break;
+
+    while (_nan_unbase64(*src) < 0 && src < srcEnd) src++, remaining--;
+    if (remaining <= 2 || *src == '=') break;
+    c = _nan_unbase64(*src++);
+
+    *dst++ = ((b & 0x0F) << 4) | ((c & 0x3C) >> 2);
+    if (dst == dstEnd) break;
+
+    while (_nan_unbase64(*src) < 0 && src < srcEnd) src++, remaining--;
+    if (remaining <= 3 || *src == '=') break;
+    d = _nan_unbase64(*src++);
+
+    *dst++ = ((c & 0x03) << 6) | (d & 0x3F);
+  }
+
+  return dst - buf;
+}
+
+//// HEX ////
+
+template<typename T> unsigned _nan_hex2bin(T c) {
+  if (c >= '0' && c <= '9') return c - '0';
+  if (c >= 'A' && c <= 'F') return 10 + (c - 'A');
+  if (c >= 'a' && c <= 'f') return 10 + (c - 'a');
+  return static_cast<unsigned>(-1);
+}
+
+template<typename T> static size_t _nan_hex_decode(
+    char* buf
+  , size_t len
+  , const T* src
+  , const size_t srcLen
+) {
+  size_t i;
+  for (i = 0; i < len && i * 2 + 1 < srcLen; ++i) {
+    unsigned a = _nan_hex2bin(src[i * 2 + 0]);
+    unsigned b = _nan_hex2bin(src[i * 2 + 1]);
+    if (!~a || !~b) return i;
+    buf[i] = a * 16 + b;
+  }
+
+  return i;
+}
+
+static bool _NanGetExternalParts(
+    v8::Handle<v8::Value> val
+  , const char** data
+  , size_t* len
+) {
+  if (node::Buffer::HasInstance(val)) {
+    *data = node::Buffer::Data(val.As<v8::Object>());
+    *len = node::Buffer::Length(val.As<v8::Object>());
+    return true;
+  }
+
+  assert(val->IsString());
+  v8::Local<v8::String> str = NanNew<v8::String>(val.As<v8::String>());
+
+  if (str->IsExternalAscii()) {
+    const v8::String::ExternalAsciiStringResource* ext;
+    ext = str->GetExternalAsciiStringResource();
+    *data = ext->data();
+    *len = ext->length();
+    return true;
+
+  } else if (str->IsExternal()) {
+    const v8::String::ExternalStringResource* ext;
+    ext = str->GetExternalStringResource();
+    *data = reinterpret_cast<const char*>(ext->data());
+    *len = ext->length();
+    return true;
+  }
+
+  return false;
+}
+
+namespace Nan {
+  enum Encoding {ASCII, UTF8, BASE64, UCS2, BINARY, HEX, BUFFER};
+}
+
+NAN_INLINE void* NanRawString(
+    v8::Handle<v8::Value> from
+  , enum Nan::Encoding encoding
+  , size_t *datalen
+  , void *buf
+  , size_t buflen
+  , int flags
+) {
+  NanScope();
+
+  size_t sz_;
+  size_t term_len = !(flags & v8::String::NO_NULL_TERMINATION);
+  char *data = NULL;
+  size_t len;
+  bool is_extern = _NanGetExternalParts(
+      from
+    , const_cast<const char**>(&data)
+    , &len);
+
+  if (is_extern && !term_len) {
+    NanSetPointerSafe(datalen, len);
+    return data;
+  }
+
+  v8::Local<v8::String> toStr = from->ToString();
+
+  char *to = static_cast<char *>(buf);
+
+  switch (encoding) {
+    case Nan::ASCII:
+#if NODE_MODULE_VERSION < 0x000C
+      sz_ = toStr->Length();
+      if (to == NULL) {
+        to = new char[sz_ + term_len];
+      } else {
+        assert(buflen >= sz_ + term_len && "too small buffer");
+      }
+      NanSetPointerSafe<size_t>(
+          datalen
+        , toStr->WriteAscii(to, 0, static_cast<int>(sz_ + term_len), flags));
+      return to;
+#endif
+    case Nan::BINARY:
+    case Nan::BUFFER:
+      sz_ = toStr->Length();
+      if (to == NULL) {
+        to = new char[sz_ + term_len];
+      } else {
+        assert(buflen >= sz_ + term_len && "too small buffer");
+      }
+#if NODE_MODULE_VERSION < 0x000C
+      {
+        uint16_t* twobytebuf = new uint16_t[sz_ + term_len];
+
+        size_t len = toStr->Write(twobytebuf, 0,
+          static_cast<int>(sz_ + term_len), flags);
+
+        for (size_t i = 0; i < sz_ + term_len && i < len + term_len; i++) {
+          unsigned char *b = reinterpret_cast<unsigned char*>(&twobytebuf[i]);
+          to[i] = *b;
+        }
+
+        NanSetPointerSafe<size_t>(datalen, len);
+
+        delete[] twobytebuf;
+        return to;
+      }
+#else
+      NanSetPointerSafe<size_t>(
+        datalen,
+        toStr->WriteOneByte(
+            reinterpret_cast<uint8_t *>(to)
+          , 0
+          , static_cast<int>(sz_ + term_len)
+          , flags));
+      return to;
+#endif
+    case Nan::UTF8:
+      sz_ = toStr->Utf8Length();
+      if (to == NULL) {
+        to = new char[sz_ + term_len];
+      } else {
+        assert(buflen >= sz_ + term_len && "too small buffer");
+      }
+      NanSetPointerSafe<size_t>(
+          datalen
+        , toStr->WriteUtf8(to, static_cast<int>(sz_ + term_len)
+            , NULL, flags)
+          - term_len);
+      return to;
+    case Nan::BASE64:
+      {
+        v8::String::Value value(toStr);
+        sz_ = _nan_base64_decoded_size(*value, value.length());
+        if (to == NULL) {
+          to = new char[sz_ + term_len];
+        } else {
+          assert(buflen >= sz_ + term_len);
+        }
+        NanSetPointerSafe<size_t>(
+            datalen
+          , _nan_base64_decode(to, sz_, *value, value.length()));
+        if (term_len) {
+          to[sz_] = '\0';
+        }
+        return to;
+      }
+    case Nan::UCS2:
+      {
+        sz_ = toStr->Length();
+        if (to == NULL) {
+          to = new char[(sz_ + term_len) * 2];
+        } else {
+          assert(buflen >= (sz_ + term_len) * 2 && "too small buffer");
+        }
+
+        int bc = 2 * toStr->Write(
+            reinterpret_cast<uint16_t *>(to)
+          , 0
+          , static_cast<int>(sz_ + term_len)
+          , flags);
+        NanSetPointerSafe<size_t>(datalen, bc);
+        return to;
+      }
+    case Nan::HEX:
+      {
+        v8::String::Value value(toStr);
+        sz_ = value.length();
+        assert(!(sz_ & 1) && "bad hex data");
+        if (to == NULL) {
+          to = new char[sz_ / 2 + term_len];
+        } else {
+          assert(buflen >= sz_ / 2 + term_len && "too small buffer");
+        }
+        NanSetPointerSafe<size_t>(
+            datalen
+          , _nan_hex_decode(to, sz_ / 2, *value, value.length()));
+      }
+      if (term_len) {
+        to[sz_ / 2] = '\0';
+      }
+      return to;
+    default:
+      assert(0 && "unknown encoding");
+  }
+  return to;
+}
+
+NAN_INLINE char* NanCString(
+    v8::Handle<v8::Value> from
+  , size_t *datalen
+  , char *buf = NULL
+  , size_t buflen = 0
+  , int flags = v8::String::NO_OPTIONS
+) {
+    return static_cast<char *>(
+      NanRawString(from, Nan::UTF8, datalen, buf, buflen, flags)
+    );
+}
+
+#endif  // NAN_H_