@quantiya/codevibe-codex-plugin 2.0.6 → 2.0.8

package/node_modules/fs-ext/example.js

@@ -0,0 +1,57 @@
+"use strict";
+
+var fs = require('fs');
+var {flock} = require('./');
+
+/**
+ * Function that locks the current file
+ * for `timeout` miliseconds
+ *
+ * The `counter` represents an index of how many
+ * times the function has been called so far
+ * (it acts as an id)
+ *
+ * The callback `cb` is optional
+ */
+function getCurrentFileSize(counter, timeout, cb) {
+  var fd = fs.openSync(__filename, 'r');
+
+  console.log("Trying to aquire lock for the %s time", counter);
+
+  flock(fd, 'exnb', function(err) {
+    if (err) {
+      return console.log("Couldn't lock file", counter);
+    }
+
+    console.log('Aquired lock', counter);
+
+    // unlock after `timeout`
+    setTimeout(function() {
+      flock(fd, 'un', function(err) {
+        if (err) {
+          return console.log("Couldn't unlock file", counter);
+        }
+
+        if (cb) { cb(); }
+      });
+    }, timeout);
+  });
+}
+
+getCurrentFileSize(1, 300, function() {
+  // this will succeed because we're calling the function
+  // after unlock
+  getCurrentFileSize(3, 2000);
+});
+// this will fail because #1 locks the file first
+getCurrentFileSize(2, 1000);
+
+// The output should be:
+/*
+Trying to aquire lock for the 1 time
+Trying to aquire lock for the 2 time
+Aquired lock 1
+Couldn't lock file 2
+Trying to aquire lock for the 3 time
+Aquired lock 3
+*/

package/node_modules/fs-ext/fs-ext.cc

@@ -0,0 +1,622 @@
+// 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.
+
+#include <node.h>
+#ifndef _WIN32
+#include <fcntl.h>
+#endif
+#include <errno.h>
+#include <stdio.h>
+#include <sys/types.h>
+#include <stdlib.h>
+#include <string.h>
+#include <nan.h>
+
+#ifndef _WIN32
+#include <sys/file.h>
+#include <unistd.h>
+#include <sys/statvfs.h>
+#endif
+
+#ifdef _WIN32
+#include <io.h>
+#include <windows.h>
+#define off_t LONGLONG
+#define _LARGEFILE_SOURCE
+#endif
+
+using namespace v8;
+using namespace node;
+
+#define THROW_BAD_ARGS Nan::ThrowTypeError("Bad argument")
+
+struct store_data_t {
+  Nan::Callback *cb;
+  int fs_op;  // operation type within this module
+  int fd;
+  int oper;
+  int arg;
+  off_t offset;
+#ifndef _WIN32
+  struct statvfs statvfs_buf;
+#endif
+  char *path;
+  int error;
+  int result;
+};
+
+#ifndef _WIN32
+static Nan::Persistent<String> f_namemax_symbol;
+static Nan::Persistent<String> f_bsize_symbol;
+static Nan::Persistent<String> f_frsize_symbol;
+
+static Nan::Persistent<String> f_blocks_symbol;
+static Nan::Persistent<String> f_bavail_symbol;
+static Nan::Persistent<String> f_bfree_symbol;
+
+static Nan::Persistent<String> f_files_symbol;
+static Nan::Persistent<String> f_favail_symbol;
+static Nan::Persistent<String> f_ffree_symbol;
+#endif
+
+#ifdef _WIN32
+  #define LOCK_SH 1
+  #define LOCK_EX 2
+  #define LOCK_NB 4
+  #define LOCK_UN 8
+#endif
+
+enum
+{
+  FS_OP_FLOCK,
+  FS_OP_SEEK,
+  FS_OP_STATVFS,
+#ifndef _WIN32
+  FS_OP_FCNTL,
+#endif
+};
+
+static void EIO_After(uv_work_t *req) {
+  Nan::HandleScope scope;
+
+  store_data_t *store_data = static_cast<store_data_t *>(req->data);
+
+  // there is always at least one argument. "error"
+  int argc = 1;
+
+  // Allocate space for two args: error plus possible additional result
+  Local<Value> argv[2];
+  Local<Object> statvfs_result;
+  // NOTE: This may need to be changed if something returns a -1
+  // for a success, which is possible.
+  if (store_data->result == -1) {
+    // If the request doesn't have a path parameter set.
+    argv[0] = Nan::ErrnoException(store_data->error, "EIO_After", "");
+  } else {
+    // error value is empty or null for non-error.
+    argv[0] = Nan::Null();
+
+    switch (store_data->fs_op) {
+      // These operations have no data to pass other than "error".
+      case FS_OP_FLOCK:
+        argc = 1;
+        break;
+
+      case FS_OP_SEEK:
+        argc = 2;
+        argv[1] = Nan::New<Number>(static_cast<double>(store_data->offset));
+        break;
+      case FS_OP_STATVFS:
+#ifndef _WIN32
+        argc = 2;
+        statvfs_result = Nan::New<Object>();
+        argv[1] = statvfs_result;
+        Nan::Set(statvfs_result, Nan::New<String>(f_namemax_symbol), Nan::New<Integer>(static_cast<uint32_t>(store_data->statvfs_buf.f_namemax)));
+        Nan::Set(statvfs_result, Nan::New<String>(f_bsize_symbol), Nan::New<Integer>(static_cast<uint32_t>(store_data->statvfs_buf.f_bsize)));
+        Nan::Set(statvfs_result, Nan::New<String>(f_frsize_symbol), Nan::New<Integer>(static_cast<uint32_t>(store_data->statvfs_buf.f_frsize)));
+        Nan::Set(statvfs_result, Nan::New<String>(f_blocks_symbol), Nan::New<Number>(store_data->statvfs_buf.f_blocks));
+        Nan::Set(statvfs_result, Nan::New<String>(f_bavail_symbol), Nan::New<Number>(store_data->statvfs_buf.f_bavail));
+        Nan::Set(statvfs_result, Nan::New<String>(f_bfree_symbol), Nan::New<Number>(store_data->statvfs_buf.f_bfree));
+        Nan::Set(statvfs_result, Nan::New<String>(f_files_symbol), Nan::New<Number>(store_data->statvfs_buf.f_files));
+        Nan::Set(statvfs_result, Nan::New<String>(f_favail_symbol), Nan::New<Number>(store_data->statvfs_buf.f_favail));
+        Nan::Set(statvfs_result, Nan::New<String>(f_ffree_symbol), Nan::New<Number>(store_data->statvfs_buf.f_ffree));
+#else
+        argc = 1;
+#endif
+        break;
+#ifndef _WIN32
+      case FS_OP_FCNTL:
+        argc = 2;
+        argv[1] = Nan::New<Number>(store_data->result);
+        break;
+#endif
+      default:
+        assert(0 && "Unhandled op type value");
+    }
+  }
+
+  Nan::TryCatch try_catch;
+
+  Nan::AsyncResource async_resource("fs-ext:EIO_After");
+  store_data->cb->Call(argc, argv, &async_resource);
+
+  if (try_catch.HasCaught()) {
+    Nan::FatalException(try_catch);
+  }
+
+  // Dispose of the persistent handle
+  delete store_data->cb;
+  delete store_data;
+  delete req;
+}
+
+static void EIO_StatVFS(uv_work_t *req) {
+  store_data_t* statvfs_data = static_cast<store_data_t *>(req->data);
+  statvfs_data->result = 0;
+#ifndef _WIN32
+  struct statvfs *data = &(statvfs_data->statvfs_buf);
+  if (statvfs(statvfs_data->path, data)) {
+    statvfs_data->result = -1;
+  	memset(data, 0, sizeof(struct statvfs));
+  };
+#endif
+  free(statvfs_data->path);
+  ;
+}
+
+#ifdef _WIN32
+static off_t _win32_lseek(int fd, off_t offset, int whence) {
+  HANDLE fh;
+  LARGE_INTEGER new_offset;
+
+  fh = (HANDLE)uv_get_osfhandle(fd);
+  if (fh == (HANDLE)-1) {
+    errno = EBADF;
+    return -1;
+  }
+
+  DWORD method;
+  switch (whence) {
+  case SEEK_SET:
+      method = FILE_BEGIN;
+      break;
+  case SEEK_CUR:
+      method = FILE_CURRENT;
+      break;
+  case SEEK_END:
+      method = FILE_END;
+      break;
+  default:
+      errno = EINVAL;
+      return -1;
+  }
+
+  LARGE_INTEGER distance;
+  distance.QuadPart = offset;
+
+  if (SetFilePointerEx(fh, distance, &new_offset, method)) {
+    return new_offset.QuadPart;
+  }
+
+  errno = EINVAL;
+  return -1;
+}
+#endif
+
+static void EIO_Seek(uv_work_t *req) {
+  store_data_t* seek_data = static_cast<store_data_t *>(req->data);
+
+#ifdef _WIN32
+  off_t offs = _win32_lseek(seek_data->fd, seek_data->offset, seek_data->oper);
+#else
+  off_t offs = lseek(seek_data->fd, seek_data->offset, seek_data->oper);
+#endif
+
+  if (offs == -1) {
+    seek_data->result = -1;
+    seek_data->error = errno;
+  } else {
+    seek_data->offset = offs;
+  }
+
+}
+
+#ifndef _WIN32
+static void EIO_Fcntl(uv_work_t *req) {
+  store_data_t* data = static_cast<store_data_t *>(req->data);
+
+  struct flock lk;
+  lk.l_start = 0;
+  lk.l_len = 0;
+  lk.l_type = 0;
+  lk.l_whence = 0;
+  lk.l_pid = 0;
+
+  int result = -1;
+  if (data->oper == F_GETLK || data->oper == F_SETLK || data->oper == F_SETLKW) {
+	if (data->oper == F_SETLK || data->oper == F_SETLKW) {
+		lk.l_whence = SEEK_SET;
+		lk.l_type   = data->arg;
+	}
+	data->result = result = fcntl(data->fd, data->oper, &lk);
+  } else {
+  	data->result = result = fcntl(data->fd, data->oper, data->arg);
+  }
+  if (result == -1) {
+   	data->error = errno;
+  }
+}
+#endif
+
+#ifdef _WIN32
+
+static void uv__crt_invalid_parameter_handler(const wchar_t* expression,
+    const wchar_t* function, const wchar_t * file, unsigned int line,
+    uintptr_t reserved) {
+  /* No-op. */
+}
+
+#define LK_LEN          0xffff0000
+
+static int _win32_flock(int fd, int oper) {
+  OVERLAPPED o;
+  HANDLE fh;
+
+  int i = -1;
+
+  fh = (HANDLE)uv_get_osfhandle(fd);
+  if (fh == (HANDLE)-1) {
+    errno = EBADF;
+    return -1;
+  }
+
+  memset(&o, 0, sizeof(o));
+
+  switch(oper) {
+  case LOCK_SH:               /* shared lock */
+      if (LockFileEx(fh, 0, 0, LK_LEN, 0, &o))
+        i = 0;
+      break;
+  case LOCK_EX:               /* exclusive lock */
+      if (LockFileEx(fh, LOCKFILE_EXCLUSIVE_LOCK, 0, LK_LEN, 0, &o))
+        i = 0;
+      break;
+  case LOCK_SH|LOCK_NB:       /* non-blocking shared lock */
+      if (LockFileEx(fh, LOCKFILE_FAIL_IMMEDIATELY, 0, LK_LEN, 0, &o))
+        i = 0;
+      break;
+  case LOCK_EX|LOCK_NB:       /* non-blocking exclusive lock */
+      if (LockFileEx(fh, LOCKFILE_EXCLUSIVE_LOCK|LOCKFILE_FAIL_IMMEDIATELY,
+                     0, LK_LEN, 0, &o))
+        i = 0;
+      break;
+  case LOCK_UN:               /* unlock lock */
+      if (UnlockFileEx(fh, 0, LK_LEN, 0, &o) ||
+          GetLastError() == ERROR_NOT_LOCKED)
+        i = 0;
+      break;
+  default:                    /* unknown */
+      errno = EINVAL;
+      return -1;
+  }
+  if (i == -1) {
+    if (GetLastError() == ERROR_LOCK_VIOLATION)
+      errno = EWOULDBLOCK;
+    else
+      errno = EINVAL;
+  }
+  return i;
+}
+#endif
+
+static void EIO_Flock(uv_work_t *req) {
+  store_data_t* flock_data = static_cast<store_data_t *>(req->data);
+
+#ifdef _WIN32
+  int i = _win32_flock(flock_data->fd, flock_data->oper);
+#else
+  int i = flock(flock_data->fd, flock_data->oper);
+#endif
+
+  flock_data->result = i;
+  flock_data->error = errno;
+
+}
+
+static NAN_METHOD(Flock) {
+  if (info.Length() < 2 || !info[0]->IsInt32() || !info[1]->IsInt32()) {
+    return THROW_BAD_ARGS;
+  }
+
+  store_data_t* flock_data = new store_data_t();
+
+  flock_data->fs_op = FS_OP_FLOCK;
+  flock_data->fd = info[0].As<v8::Int32>()->Value();
+  flock_data->oper = info[1].As<v8::Int32>()->Value();
+
+  if (info[2]->IsFunction()) {
+    flock_data->cb = new Nan::Callback((Local<Function>) info[2].As<Function>());
+    uv_work_t *req = new uv_work_t;
+    req->data = flock_data;
+    uv_queue_work(uv_default_loop(), req, EIO_Flock, (uv_after_work_cb)EIO_After);
+    info.GetReturnValue().SetUndefined();
+  } else {
+#ifdef _WIN32
+    int i = _win32_flock(flock_data->fd, flock_data->oper);
+#else
+    int i = flock(flock_data->fd, flock_data->oper);
+#endif
+    delete flock_data;
+    if (i != 0) return Nan::ThrowError(Nan::ErrnoException(errno, "Flock", ""));
+    info.GetReturnValue().SetUndefined();
+  }
+}
+
+
+#ifdef _LARGEFILE_SOURCE
+static inline int IsInt64(double x) {
+  return x == static_cast<double>(static_cast<int64_t>(x));
+}
+#endif
+
+#ifndef _LARGEFILE_SOURCE
+#define ASSERT_OFFSET(a) \
+  if (!(a)->IsUndefined() && !(a)->IsNull() && !(a)->IsInt32()) { \
+    return Nan::ThrowTypeError("Not an integer"); \
+  }
+#define GET_OFFSET(a) ((a)->IsInt32() ? (a).As<v8::Int32>()->Value() : -1)
+#else
+#define ASSERT_OFFSET(a) \
+  if (!(a)->IsUndefined() && !(a)->IsNull() && !((a)->IsNumber() && IsInt64((a).As<v8::Number>()->Value()))) { \
+    return Nan::ThrowTypeError("Not an integer"); \
+  }
+#define GET_OFFSET(a) ((a)->IsNumber() ? static_cast<int64_t>((a).As<v8::Number>()->Value()) : -1)
+#endif
+
+//  fs.seek(fd, position, whence [, callback] )
+
+static NAN_METHOD(Seek) {
+  if (info.Length() < 3 ||
+     !info[0]->IsInt32() ||
+     !info[2]->IsInt32()) {
+    return THROW_BAD_ARGS;
+  }
+
+  int fd = info[0].As<v8::Int32>()->Value();
+  ASSERT_OFFSET(info[1]);
+  off_t offs = GET_OFFSET(info[1]);
+  int whence = info[2].As<v8::Int32>()->Value();
+
+  if ( ! info[3]->IsFunction()) {
+#ifdef _WIN32
+    off_t offs_result = _win32_lseek(fd, offs, whence);
+#else
+    off_t offs_result = lseek(fd, offs, whence);
+#endif
+    if (offs_result == -1) return Nan::ThrowError(Nan::ErrnoException(errno, "Seek", ""));
+    info.GetReturnValue().Set(Nan::New<Number>(static_cast<double>(offs_result)));
+    return;
+  }
+
+  store_data_t* seek_data = new store_data_t();
+
+  seek_data->cb = new Nan::Callback((Local<Function>) info[3].As<Function>());
+  seek_data->fs_op = FS_OP_SEEK;
+  seek_data->fd = fd;
+  seek_data->offset = offs;
+  seek_data->oper = whence;
+
+  uv_work_t *req = new uv_work_t;
+  req->data = seek_data;
+  uv_queue_work(uv_default_loop(), req, EIO_Seek, (uv_after_work_cb)EIO_After);
+
+  info.GetReturnValue().SetUndefined();
+}
+
+//  fs.fcntl(fd, cmd, [arg])
+
+#ifndef _WIN32
+static NAN_METHOD(Fcntl) {
+  if (info.Length() < 3 ||
+     !info[0]->IsInt32() ||
+     !info[1]->IsInt32() ||
+     !info[2]->IsInt32()) {
+    return THROW_BAD_ARGS;
+  }
+
+  int fd = info[0].As<v8::Int32>()->Value();
+  int cmd = info[1].As<v8::Int32>()->Value();
+  int arg = info[2].As<v8::Int32>()->Value();
+
+  if ( ! info[3]->IsFunction()) {
+    int result = fcntl(fd, cmd, arg);
+    if (result == -1) return Nan::ThrowError(Nan::ErrnoException(errno, "Fcntl", ""));
+    info.GetReturnValue().Set(Nan::New<Number>(result));
+    return;
+  }
+
+  store_data_t* data = new store_data_t();
+
+  data->cb = new Nan::Callback((Local<Function>) info[3].As<Function>());
+  data->fs_op = FS_OP_FCNTL;
+  data->fd = fd;
+  data->oper = cmd;
+  data->arg = arg;
+
+  uv_work_t *req = new uv_work_t;
+  req->data = data;
+  uv_queue_work(uv_default_loop(), req, EIO_Fcntl, (uv_after_work_cb)EIO_After);
+
+  info.GetReturnValue().SetUndefined();
+}
+#endif
+
+// Wrapper for statvfs(2).
+//   fs.statVFS( path, [callback] )
+
+static NAN_METHOD(StatVFS) {
+  if (info.Length() < 1 ||
+      !info[0]->IsString() ) {
+    return THROW_BAD_ARGS;
+  }
+
+  Nan::Utf8String path(info[0]);
+
+  // Synchronous call needs much less work
+  if (!info[1]->IsFunction()) {
+#ifndef _WIN32
+    struct statvfs buf;
+    int ret = statvfs(*path, &buf);
+    if (ret != 0) return Nan::ThrowError(Nan::ErrnoException(errno, "statvfs", "", *path));
+    Local<Object> result = Nan::New<Object>();
+    Nan::Set(result, Nan::New<String>(f_namemax_symbol), Nan::New<Integer>(static_cast<uint32_t>(buf.f_namemax)));
+    Nan::Set(result, Nan::New<String>(f_bsize_symbol), Nan::New<Integer>(static_cast<uint32_t>(buf.f_bsize)));
+    Nan::Set(result, Nan::New<String>(f_frsize_symbol), Nan::New<Integer>(static_cast<uint32_t>(buf.f_frsize)));
+
+    Nan::Set(result, Nan::New<String>(f_blocks_symbol), Nan::New<Number>(buf.f_blocks));
+    Nan::Set(result, Nan::New<String>(f_bavail_symbol), Nan::New<Number>(buf.f_bavail));
+    Nan::Set(result, Nan::New<String>(f_bfree_symbol), Nan::New<Number>(buf.f_bfree));
+
+    Nan::Set(result, Nan::New<String>(f_files_symbol), Nan::New<Number>(buf.f_files));
+    Nan::Set(result, Nan::New<String>(f_favail_symbol), Nan::New<Number>(buf.f_favail));
+    Nan::Set(result, Nan::New<String>(f_ffree_symbol), Nan::New<Number>(buf.f_ffree));
+    info.GetReturnValue().Set(result);
+#else
+    info.GetReturnValue().SetUndefined();
+#endif
+    return;
+  }
+
+  store_data_t* statvfs_data = new store_data_t();
+
+  statvfs_data->cb = new Nan::Callback((Local<Function>) info[1].As<Function>());
+  statvfs_data->fs_op = FS_OP_STATVFS;
+  statvfs_data->path = strdup(*path);
+
+  uv_work_t *req = new uv_work_t;
+  req->data = statvfs_data;
+  uv_queue_work(uv_default_loop(), req, EIO_StatVFS,(uv_after_work_cb)EIO_After);
+
+  info.GetReturnValue().SetUndefined();
+}
+
+extern "C"
+NAN_MODULE_INIT(init)
+{
+  Nan::HandleScope scope;
+
+#ifdef _WIN32
+  _set_invalid_parameter_handler(uv__crt_invalid_parameter_handler);
+#endif
+
+  v8::Local<v8::Object> constants = Nan::New<v8::Object>();
+
+#ifdef SEEK_SET
+  NODE_DEFINE_CONSTANT(constants, SEEK_SET);
+#endif
+
+#ifdef SEEK_CUR
+  NODE_DEFINE_CONSTANT(constants, SEEK_CUR);
+#endif
+
+#ifdef SEEK_END
+  NODE_DEFINE_CONSTANT(constants, SEEK_END);
+#endif
+
+#ifdef LOCK_SH
+  NODE_DEFINE_CONSTANT(constants, LOCK_SH);
+#endif
+
+#ifdef LOCK_EX
+  NODE_DEFINE_CONSTANT(constants, LOCK_EX);
+#endif
+
+#ifdef LOCK_NB
+  NODE_DEFINE_CONSTANT(constants, LOCK_NB);
+#endif
+
+#ifdef LOCK_UN
+  NODE_DEFINE_CONSTANT(constants, LOCK_UN);
+#endif
+
+#ifdef F_GETFD
+  NODE_DEFINE_CONSTANT(constants, F_GETFD);
+#endif
+
+#ifdef F_SETFD
+  NODE_DEFINE_CONSTANT(constants, F_SETFD);
+#endif
+
+#ifdef FD_CLOEXEC
+  NODE_DEFINE_CONSTANT(constants, FD_CLOEXEC);
+#endif
+
+#ifdef F_RDLCK
+  NODE_DEFINE_CONSTANT(constants, F_RDLCK);
+#endif
+
+#ifdef F_WRLCK
+  NODE_DEFINE_CONSTANT(constants, F_WRLCK);
+#endif
+
+#ifdef F_UNLCK
+  NODE_DEFINE_CONSTANT(constants, F_UNLCK);
+#endif
+
+#ifdef F_SETLK
+  NODE_DEFINE_CONSTANT(constants, F_SETLK);
+#endif
+
+#ifdef F_GETLK
+  NODE_DEFINE_CONSTANT(constants, F_GETLK);
+#endif
+
+#ifdef F_SETLKW
+  NODE_DEFINE_CONSTANT(constants, F_SETLKW);
+#endif
+
+  Nan::Set(target, Nan::New("constants").ToLocalChecked(), constants);
+
+  Export(target, "seek", Seek);
+#ifndef _WIN32
+  Export(target, "fcntl", Fcntl);
+#endif
+  Export(target, "flock", Flock);
+  Export(target, "statVFS", StatVFS);
+
+#ifndef _WIN32
+  f_namemax_symbol.Reset(Nan::New<String>("f_namemax").ToLocalChecked());
+  f_bsize_symbol.Reset(Nan::New<String>("f_bsize").ToLocalChecked());
+  f_frsize_symbol.Reset(Nan::New<String>("f_frsize").ToLocalChecked());
+
+  f_blocks_symbol.Reset(Nan::New<String>("f_blocks").ToLocalChecked());
+  f_bavail_symbol.Reset(Nan::New<String>("f_bavail").ToLocalChecked());
+  f_bfree_symbol.Reset(Nan::New<String>("f_bfree").ToLocalChecked());
+
+  f_files_symbol.Reset(Nan::New<String>("f_files").ToLocalChecked());
+  f_favail_symbol.Reset(Nan::New<String>("f_favail").ToLocalChecked());
+  f_ffree_symbol.Reset(Nan::New<String>("f_ffree").ToLocalChecked());
+#endif
+}
+
+#if NODE_MODULE_VERSION > 1
+  NODE_MODULE_INIT() {
+    init(exports);
+  }
+#endif