diff --git a/addons/godot_xterm/native/src/node_pty/unix/pty.cc b/addons/godot_xterm/native/src/node_pty/unix/pty.cc
index ce44a3e..e776649 100644
--- a/addons/godot_xterm/native/src/node_pty/unix/pty.cc
+++ b/addons/godot_xterm/native/src/node_pty/unix/pty.cc
@@ -17,18 +17,18 @@
  * Includes
  */
 
-#include <nan.h>
 #include <errno.h>
-#include <string.h>
+#include <nan.h>
 #include <stdlib.h>
+#include <string.h>
 #include <unistd.h>
 
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <sys/ioctl.h>
-#include <sys/wait.h>
 #include <fcntl.h>
 #include <signal.h>
+#include <sys/ioctl.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <sys/wait.h>
 
 /* forkpty */
 /* http://www.gnu.org/software/gnulib/manual/html_node/forkpty.html */
@@ -48,10 +48,10 @@
 
 /* Some platforms name VWERASE and VDISCARD differently */
 #if !defined(VWERASE) && defined(VWERSE)
-#define VWERASE	VWERSE
+#define VWERASE VWERSE
 #endif
 #if !defined(VDISCARD) && defined(VDISCRD)
-#define VDISCARD	VDISCRD
+#define VDISCARD VDISCRD
 #endif
 
 /* environ for execvpe */
@@ -65,11 +65,11 @@ extern char **environ;
 
 /* for pty_getproc */
 #if defined(__linux__)
-#include <stdio.h>
 #include <stdint.h>
+#include <stdio.h>
 #elif defined(__APPLE__)
-#include <sys/sysctl.h>
 #include <libproc.h>
+#include <sys/sysctl.h>
 #endif
 
 /* NSIG - macro for highest signal + 1, should be defined */
@@ -103,50 +103,33 @@ NAN_METHOD(PtyGetProc);
  * Functions
  */
 
-static int
-pty_execvpe(const char *, char **, char **);
+static int pty_execvpe(const char *, char **, char **);
 
-static int
-pty_nonblock(int);
+static int pty_nonblock(int);
 
-static char *
-pty_getproc(int, char *);
+static char *pty_getproc(int, char *);
 
-static int
-pty_openpty(int *, int *, char *,
-            const struct termios *,
-            const struct winsize *);
+static int pty_openpty(int *, int *, char *, const struct termios *,
+                       const struct winsize *);
 
-static pid_t
-pty_forkpty(int *, char *,
-            const struct termios *,
-            const struct winsize *);
+static pid_t pty_forkpty(int *, char *, const struct termios *,
+                         const struct winsize *);
 
-static void
-pty_waitpid(void *);
+static void pty_waitpid(void *);
 
-static void
-pty_after_waitpid(uv_async_t *);
+static void pty_after_waitpid(uv_async_t *);
 
-static void
-pty_after_close(uv_handle_t *);
+static void pty_after_close(uv_handle_t *);
 
 NAN_METHOD(PtyFork) {
   Nan::HandleScope scope;
 
-  if (info.Length() != 10 ||
-      !info[0]->IsString() ||
-      !info[1]->IsArray() ||
-      !info[2]->IsArray() ||
-      !info[3]->IsString() ||
-      !info[4]->IsNumber() ||
-      !info[5]->IsNumber() ||
-      !info[6]->IsNumber() ||
-      !info[7]->IsNumber() ||
-      !info[8]->IsBoolean() ||
-      !info[9]->IsFunction()) {
-    return Nan::ThrowError(
-        "Usage: pty.fork(file, args, env, cwd, cols, rows, uid, gid, utf8, onexit)");
+  if (info.Length() != 10 || !info[0]->IsString() || !info[1]->IsArray() ||
+      !info[2]->IsArray() || !info[3]->IsString() || !info[4]->IsNumber() ||
+      !info[5]->IsNumber() || !info[6]->IsNumber() || !info[7]->IsNumber() ||
+      !info[8]->IsBoolean() || !info[9]->IsFunction()) {
+    return Nan::ThrowError("Usage: pty.fork(file, args, env, cwd, cols, rows, "
+                           "uid, gid, utf8, onexit)");
   }
 
   // file
@@ -157,19 +140,19 @@ NAN_METHOD(PtyFork) {
   v8::Local<v8::Array> argv_ = v8::Local<v8::Array>::Cast(info[1]);
   int argc = argv_->Length();
   int argl = argc + 1 + 1;
-  char **argv = new char*[argl];
+  char **argv = new char *[argl];
   argv[0] = strdup(*file);
-  argv[argl-1] = NULL;
+  argv[argl - 1] = NULL;
   for (; i < argc; i++) {
     Nan::Utf8String arg(Nan::Get(argv_, i).ToLocalChecked());
-    argv[i+1] = strdup(*arg);
+    argv[i + 1] = strdup(*arg);
   }
 
   // env
   i = 0;
   v8::Local<v8::Array> env_ = v8::Local<v8::Array>::Cast(info[2]);
   int envc = env_->Length();
-  char **env = new char*[envc+1];
+  char **env = new char *[envc + 1];
   env[envc] = NULL;
   for (; i < envc; i++) {
     Nan::Utf8String pair(Nan::Get(env_, i).ToLocalChecked());
@@ -198,7 +181,8 @@ NAN_METHOD(PtyFork) {
   }
   term->c_oflag = OPOST | ONLCR;
   term->c_cflag = CREAD | CS8 | HUPCL;
-  term->c_lflag = ICANON | ISIG | IEXTEN | ECHO | ECHOE | ECHOK | ECHOKE | ECHOCTL;
+  term->c_lflag =
+      ICANON | ISIG | IEXTEN | ECHO | ECHOE | ECHOK | ECHOKE | ECHOCTL;
 
   term->c_cc[VEOF] = 4;
   term->c_cc[VEOL] = -1;
@@ -217,10 +201,10 @@ NAN_METHOD(PtyFork) {
   term->c_cc[VMIN] = 1;
   term->c_cc[VTIME] = 0;
 
-  #if (__APPLE__)
+#if (__APPLE__)
   term->c_cc[VDSUSP] = 25;
   term->c_cc[VSTATUS] = 20;
-  #endif
+#endif
 
   cfsetispeed(term, B38400);
   cfsetospeed(term, B38400);
@@ -249,7 +233,7 @@ NAN_METHOD(PtyFork) {
     sig_action.sa_handler = SIG_DFL;
     sig_action.sa_flags = 0;
     sigemptyset(&sig_action.sa_mask);
-    for (int i = 0 ; i < NSIG ; i++) {    // NSIG is a macro for all signals + 1
+    for (int i = 0; i < NSIG; i++) { // NSIG is a macro for all signals + 1
       sigaction(i, &sig_action, NULL);
     }
   }
@@ -257,67 +241,66 @@ NAN_METHOD(PtyFork) {
   pthread_sigmask(SIG_SETMASK, &oldmask, NULL);
 
   if (pid) {
-    for (i = 0; i < argl; i++) free(argv[i]);
+    for (i = 0; i < argl; i++)
+      free(argv[i]);
     delete[] argv;
-    for (i = 0; i < envc; i++) free(env[i]);
+    for (i = 0; i < envc; i++)
+      free(env[i]);
     delete[] env;
     free(cwd);
   }
 
   switch (pid) {
-    case -1:
-      return Nan::ThrowError("forkpty(3) failed.");
-    case 0:
-      if (strlen(cwd)) {
-        if (chdir(cwd) == -1) {
-          perror("chdir(2) failed.");
-          _exit(1);
-        }
+  case -1:
+    return Nan::ThrowError("forkpty(3) failed.");
+  case 0:
+    if (strlen(cwd)) {
+      if (chdir(cwd) == -1) {
+        perror("chdir(2) failed.");
+        _exit(1);
       }
+    }
 
-      if (uid != -1 && gid != -1) {
-        if (setgid(gid) == -1) {
-          perror("setgid(2) failed.");
-          _exit(1);
-        }
-        if (setuid(uid) == -1) {
-          perror("setuid(2) failed.");
-          _exit(1);
-        }
+    if (uid != -1 && gid != -1) {
+      if (setgid(gid) == -1) {
+        perror("setgid(2) failed.");
+        _exit(1);
       }
-
-      pty_execvpe(argv[0], argv, env);
-
-      perror("execvp(3) failed.");
-      _exit(1);
-    default:
-      if (pty_nonblock(master) == -1) {
-        return Nan::ThrowError("Could not set master fd to nonblocking.");
+      if (setuid(uid) == -1) {
+        perror("setuid(2) failed.");
+        _exit(1);
       }
+    }
 
-      v8::Local<v8::Object> obj = Nan::New<v8::Object>();
-      Nan::Set(obj,
-        Nan::New<v8::String>("fd").ToLocalChecked(),
-        Nan::New<v8::Number>(master));
-      Nan::Set(obj,
-        Nan::New<v8::String>("pid").ToLocalChecked(),
-        Nan::New<v8::Number>(pid));
-      Nan::Set(obj,
-        Nan::New<v8::String>("pty").ToLocalChecked(),
-        Nan::New<v8::String>(ptsname(master)).ToLocalChecked());
+    pty_execvpe(argv[0], argv, env);
 
-      pty_baton *baton = new pty_baton();
-      baton->exit_code = 0;
-      baton->signal_code = 0;
-      baton->cb.Reset(v8::Local<v8::Function>::Cast(info[9]));
-      baton->pid = pid;
-      baton->async.data = baton;
+    perror("execvp(3) failed.");
+    _exit(1);
+  default:
+    if (pty_nonblock(master) == -1) {
+      return Nan::ThrowError("Could not set master fd to nonblocking.");
+    }
 
-      uv_async_init(uv_default_loop(), &baton->async, pty_after_waitpid);
+    v8::Local<v8::Object> obj = Nan::New<v8::Object>();
+    Nan::Set(obj, Nan::New<v8::String>("fd").ToLocalChecked(),
+             Nan::New<v8::Number>(master));
+    Nan::Set(obj, Nan::New<v8::String>("pid").ToLocalChecked(),
+             Nan::New<v8::Number>(pid));
+    Nan::Set(obj, Nan::New<v8::String>("pty").ToLocalChecked(),
+             Nan::New<v8::String>(ptsname(master)).ToLocalChecked());
 
-      uv_thread_create(&baton->tid, pty_waitpid, static_cast<void*>(baton));
+    pty_baton *baton = new pty_baton();
+    baton->exit_code = 0;
+    baton->signal_code = 0;
+    baton->cb.Reset(v8::Local<v8::Function>::Cast(info[9]));
+    baton->pid = pid;
+    baton->async.data = baton;
 
-      return info.GetReturnValue().Set(obj);
+    uv_async_init(uv_default_loop(), &baton->async, pty_after_waitpid);
+
+    uv_thread_create(&baton->tid, pty_waitpid, static_cast<void *>(baton));
+
+    return info.GetReturnValue().Set(obj);
   }
 
   return info.GetReturnValue().SetUndefined();
@@ -326,9 +309,7 @@ NAN_METHOD(PtyFork) {
 NAN_METHOD(PtyOpen) {
   Nan::HandleScope scope;
 
-  if (info.Length() != 2 ||
-      !info[0]->IsNumber() ||
-      !info[1]->IsNumber()) {
+  if (info.Length() != 2 || !info[0]->IsNumber() || !info[1]->IsNumber()) {
     return Nan::ThrowError("Usage: pty.open(cols, rows)");
   }
 
@@ -356,15 +337,12 @@ NAN_METHOD(PtyOpen) {
   }
 
   v8::Local<v8::Object> obj = Nan::New<v8::Object>();
-  Nan::Set(obj,
-    Nan::New<v8::String>("master").ToLocalChecked(),
-    Nan::New<v8::Number>(master));
-  Nan::Set(obj,
-    Nan::New<v8::String>("slave").ToLocalChecked(),
-    Nan::New<v8::Number>(slave));
-  Nan::Set(obj,
-    Nan::New<v8::String>("pty").ToLocalChecked(),
-    Nan::New<v8::String>(ptsname(master)).ToLocalChecked());
+  Nan::Set(obj, Nan::New<v8::String>("master").ToLocalChecked(),
+           Nan::New<v8::Number>(master));
+  Nan::Set(obj, Nan::New<v8::String>("slave").ToLocalChecked(),
+           Nan::New<v8::Number>(slave));
+  Nan::Set(obj, Nan::New<v8::String>("pty").ToLocalChecked(),
+           Nan::New<v8::String>(ptsname(master)).ToLocalChecked());
 
   return info.GetReturnValue().Set(obj);
 }
@@ -372,9 +350,7 @@ NAN_METHOD(PtyOpen) {
 NAN_METHOD(PtyResize) {
   Nan::HandleScope scope;
 
-  if (info.Length() != 3 ||
-      !info[0]->IsNumber() ||
-      !info[1]->IsNumber() ||
+  if (info.Length() != 3 || !info[0]->IsNumber() || !info[1]->IsNumber() ||
       !info[2]->IsNumber()) {
     return Nan::ThrowError("Usage: pty.resize(fd, cols, rows)");
   }
@@ -389,10 +365,14 @@ NAN_METHOD(PtyResize) {
 
   if (ioctl(fd, TIOCSWINSZ, &winp) == -1) {
     switch (errno) {
-      case EBADF: return Nan::ThrowError("ioctl(2) failed, EBADF");
-      case EFAULT: return Nan::ThrowError("ioctl(2) failed, EFAULT");
-      case EINVAL: return Nan::ThrowError("ioctl(2) failed, EINVAL");
-      case ENOTTY: return Nan::ThrowError("ioctl(2) failed, ENOTTY");
+    case EBADF:
+      return Nan::ThrowError("ioctl(2) failed, EBADF");
+    case EFAULT:
+      return Nan::ThrowError("ioctl(2) failed, EFAULT");
+    case EINVAL:
+      return Nan::ThrowError("ioctl(2) failed, EINVAL");
+    case ENOTTY:
+      return Nan::ThrowError("ioctl(2) failed, ENOTTY");
     }
     return Nan::ThrowError("ioctl(2) failed");
   }
@@ -406,9 +386,7 @@ NAN_METHOD(PtyResize) {
 NAN_METHOD(PtyGetProc) {
   Nan::HandleScope scope;
 
-  if (info.Length() != 2 ||
-      !info[0]->IsNumber() ||
-      !info[1]->IsString()) {
+  if (info.Length() != 2 || !info[0]->IsNumber() || !info[1]->IsString()) {
     return Nan::ThrowError("Usage: pty.process(fd, tty)");
   }
 
@@ -434,8 +412,7 @@ NAN_METHOD(PtyGetProc) {
 
 // execvpe(3) is not portable.
 // http://www.gnu.org/software/gnulib/manual/html_node/execvpe.html
-static int
-pty_execvpe(const char *file, char **argv, char **envp) {
+static int pty_execvpe(const char *file, char **argv, char **envp) {
   char **old = environ;
   environ = envp;
   int ret = execvp(file, argv);
@@ -447,10 +424,10 @@ pty_execvpe(const char *file, char **argv, char **envp) {
  * Nonblocking FD
  */
 
-static int
-pty_nonblock(int fd) {
+static int pty_nonblock(int fd) {
   int flags = fcntl(fd, F_GETFL, 0);
-  if (flags == -1) return -1;
+  if (flags == -1)
+    return -1;
   return fcntl(fd, F_SETFL, flags | O_NONBLOCK);
 }
 
@@ -459,12 +436,11 @@ pty_nonblock(int fd) {
  * Wait for SIGCHLD to read exit status.
  */
 
-static void
-pty_waitpid(void *data) {
+static void pty_waitpid(void *data) {
   int ret;
   int stat_loc;
 
-  pty_baton *baton = static_cast<pty_baton*>(data);
+  pty_baton *baton = static_cast<pty_baton *>(data);
 
   errno = 0;
 
@@ -497,14 +473,13 @@ pty_waitpid(void *data) {
  * Callback after exit status has been read.
  */
 
-static void
-pty_after_waitpid(uv_async_t *async) {
+static void pty_after_waitpid(uv_async_t *async) {
   Nan::HandleScope scope;
-  pty_baton *baton = static_cast<pty_baton*>(async->data);
+  pty_baton *baton = static_cast<pty_baton *>(async->data);
 
   v8::Local<v8::Value> argv[] = {
-    Nan::New<v8::Integer>(baton->exit_code),
-    Nan::New<v8::Integer>(baton->signal_code),
+      Nan::New<v8::Integer>(baton->exit_code),
+      Nan::New<v8::Integer>(baton->signal_code),
   };
 
   v8::Local<v8::Function> cb = Nan::New<v8::Function>(baton->cb);
@@ -521,10 +496,9 @@ pty_after_waitpid(uv_async_t *async) {
  * uv_close() callback - free handle data
  */
 
-static void
-pty_after_close(uv_handle_t *handle) {
+static void pty_after_close(uv_handle_t *handle) {
   uv_async_t *async = (uv_async_t *)handle;
-  pty_baton *baton = static_cast<pty_baton*>(async->data);
+  pty_baton *baton = static_cast<pty_baton *>(async->data);
   delete baton;
 }
 
@@ -552,8 +526,7 @@ pty_after_close(uv_handle_t *handle) {
 
 #if defined(__linux__)
 
-static char *
-pty_getproc(int fd, char *tty) {
+static char *pty_getproc(int fd, char *tty) {
   FILE *f;
   char *path, *buf;
   size_t len;
@@ -566,7 +539,8 @@ pty_getproc(int fd, char *tty) {
   }
 
   r = asprintf(&path, "/proc/%lld/cmdline", (long long)pgrp);
-  if (r == -1 || path == NULL) return NULL;
+  if (r == -1 || path == NULL)
+    return NULL;
 
   if ((f = fopen(path, "r")) == NULL) {
     free(path);
@@ -578,9 +552,11 @@ pty_getproc(int fd, char *tty) {
   len = 0;
   buf = NULL;
   while ((ch = fgetc(f)) != EOF) {
-    if (ch == '\0') break;
+    if (ch == '\0')
+      break;
     buf = (char *)realloc(buf, len + 2);
-    if (buf == NULL) return NULL;
+    if (buf == NULL)
+      return NULL;
     buf[len++] = ch;
   }
 
@@ -594,9 +570,8 @@ pty_getproc(int fd, char *tty) {
 
 #elif defined(__APPLE__)
 
-static char *
-pty_getproc(int fd, char *tty) {
-  int mib[4] = { CTL_KERN, KERN_PROC, KERN_PROC_PID, 0 };
+static char *pty_getproc(int fd, char *tty) {
+  int mib[4] = {CTL_KERN, KERN_PROC, KERN_PROC_PID, 0};
   size_t size;
   struct kinfo_proc kp;
 
@@ -618,10 +593,7 @@ pty_getproc(int fd, char *tty) {
 
 #else
 
-static char *
-pty_getproc(int fd, char *tty) {
-  return NULL;
-}
+static char *pty_getproc(int fd, char *tty) { return NULL; }
 
 #endif
 
@@ -629,36 +601,43 @@ pty_getproc(int fd, char *tty) {
  * openpty(3) / forkpty(3)
  */
 
-static int
-pty_openpty(int *amaster,
-            int *aslave,
-            char *name,
-            const struct termios *termp,
-            const struct winsize *winp) {
+static int pty_openpty(int *amaster, int *aslave, char *name,
+                       const struct termios *termp,
+                       const struct winsize *winp) {
 #if defined(__sun)
   char *slave_name;
   int slave;
   int master = open("/dev/ptmx", O_RDWR | O_NOCTTY);
-  if (master == -1) return -1;
-  if (amaster) *amaster = master;
+  if (master == -1)
+    return -1;
+  if (amaster)
+    *amaster = master;
 
-  if (grantpt(master) == -1) goto err;
-  if (unlockpt(master) == -1) goto err;
+  if (grantpt(master) == -1)
+    goto err;
+  if (unlockpt(master) == -1)
+    goto err;
 
   slave_name = ptsname(master);
-  if (slave_name == NULL) goto err;
-  if (name) strcpy(name, slave_name);
+  if (slave_name == NULL)
+    goto err;
+  if (name)
+    strcpy(name, slave_name);
 
   slave = open(slave_name, O_RDWR | O_NOCTTY);
-  if (slave == -1) goto err;
-  if (aslave) *aslave = slave;
+  if (slave == -1)
+    goto err;
+  if (aslave)
+    *aslave = slave;
 
   ioctl(slave, I_PUSH, "ptem");
   ioctl(slave, I_PUSH, "ldterm");
   ioctl(slave, I_PUSH, "ttcompat");
 
-  if (termp) tcsetattr(slave, TCSAFLUSH, termp);
-  if (winp) ioctl(slave, TIOCSWINSZ, winp);
+  if (termp)
+    tcsetattr(slave, TCSAFLUSH, termp);
+  if (winp)
+    ioctl(slave, TIOCSWINSZ, winp);
 
   return 0;
 
@@ -670,46 +649,46 @@ err:
 #endif
 }
 
-static pid_t
-pty_forkpty(int *amaster,
-            char *name,
-            const struct termios *termp,
-            const struct winsize *winp) {
+static pid_t pty_forkpty(int *amaster, char *name, const struct termios *termp,
+                         const struct winsize *winp) {
 #if defined(__sun)
   int master, slave;
 
   int ret = pty_openpty(&master, &slave, name, termp, winp);
-  if (ret == -1) return -1;
-  if (amaster) *amaster = master;
+  if (ret == -1)
+    return -1;
+  if (amaster)
+    *amaster = master;
 
   pid_t pid = fork();
 
   switch (pid) {
-    case -1:  // error in fork, we are still in parent
-      close(master);
-      close(slave);
-      return -1;
-    case 0:  // we are in the child process
-      close(master);
-      setsid();
+  case -1: // error in fork, we are still in parent
+    close(master);
+    close(slave);
+    return -1;
+  case 0: // we are in the child process
+    close(master);
+    setsid();
 
 #if defined(TIOCSCTTY)
-      // glibc does this
-      if (ioctl(slave, TIOCSCTTY, NULL) == -1) {
-        _exit(1);
-      }
+    // glibc does this
+    if (ioctl(slave, TIOCSCTTY, NULL) == -1) {
+      _exit(1);
+    }
 #endif
 
-      dup2(slave, 0);
-      dup2(slave, 1);
-      dup2(slave, 2);
+    dup2(slave, 0);
+    dup2(slave, 1);
+    dup2(slave, 2);
 
-      if (slave > 2) close(slave);
-
-      return 0;
-    default:  // we are in the parent process
+    if (slave > 2)
       close(slave);
-      return pid;
+
+    return 0;
+  default: // we are in the parent process
+    close(slave);
+    return pid;
   }
 
   return -1;
@@ -718,7 +697,6 @@ pty_forkpty(int *amaster,
 #endif
 }
 
-
 /**
  * Init
  */
diff --git a/addons/godot_xterm/native/src/node_pty/win/conpty.cc b/addons/godot_xterm/native/src/node_pty/win/conpty.cc
index 4500f6e..65128a3 100644
--- a/addons/godot_xterm/native/src/node_pty/win/conpty.cc
+++ b/addons/godot_xterm/native/src/node_pty/win/conpty.cc
@@ -8,33 +8,37 @@
  *   with pseudo-terminal file descriptors.
  */
 
-// node versions lower than 10 define this as 0x502 which disables many of the definitions needed to compile
+// node versions lower than 10 define this as 0x502 which disables many of the
+// definitions needed to compile
 #include <node_version.h>
 #if NODE_MODULE_VERSION <= 57
-  #define _WIN32_WINNT 0x600
+#define _WIN32_WINNT 0x600
 #endif
 
+#include "path_util.h"
+#include <Shlwapi.h> // PathCombine, PathIsRelative
+#include <Windows.h>
 #include <iostream>
 #include <nan.h>
-#include <Shlwapi.h> // PathCombine, PathIsRelative
 #include <sstream>
 #include <string>
-#include <vector>
-#include <Windows.h>
 #include <strsafe.h>
-#include "path_util.h"
+#include <vector>
 
 extern "C" void init(v8::Local<v8::Object>);
 
-// Taken from the RS5 Windows SDK, but redefined here in case we're targeting <= 17134
+// Taken from the RS5 Windows SDK, but redefined here in case we're targeting <=
+// 17134
 #ifndef PROC_THREAD_ATTRIBUTE_PSEUDOCONSOLE
-#define PROC_THREAD_ATTRIBUTE_PSEUDOCONSOLE \
+#define PROC_THREAD_ATTRIBUTE_PSEUDOCONSOLE                                    \
   ProcThreadAttributeValue(22, FALSE, TRUE, FALSE)
 
-typedef VOID* HPCON;
-typedef HRESULT (__stdcall *PFNCREATEPSEUDOCONSOLE)(COORD c, HANDLE hIn, HANDLE hOut, DWORD dwFlags, HPCON* phpcon);
-typedef HRESULT (__stdcall *PFNRESIZEPSEUDOCONSOLE)(HPCON hpc, COORD newSize);
-typedef void (__stdcall *PFNCLOSEPSEUDOCONSOLE)(HPCON hpc);
+typedef VOID *HPCON;
+typedef HRESULT(__stdcall *PFNCREATEPSEUDOCONSOLE)(COORD c, HANDLE hIn,
+                                                   HANDLE hOut, DWORD dwFlags,
+                                                   HPCON *phpcon);
+typedef HRESULT(__stdcall *PFNRESIZEPSEUDOCONSOLE)(HPCON hpc, COORD newSize);
+typedef void(__stdcall *PFNCLOSEPSEUDOCONSOLE)(HPCON hpc);
 
 #endif
 
@@ -50,15 +54,16 @@ struct pty_baton {
   uv_async_t async;
   uv_thread_t tid;
 
-  pty_baton(int _id, HANDLE _hIn, HANDLE _hOut, HPCON _hpc) : id(_id), hIn(_hIn), hOut(_hOut), hpc(_hpc) {};
+  pty_baton(int _id, HANDLE _hIn, HANDLE _hOut, HPCON _hpc)
+      : id(_id), hIn(_hIn), hOut(_hOut), hpc(_hpc){};
 };
 
-static std::vector<pty_baton*> ptyHandles;
+static std::vector<pty_baton *> ptyHandles;
 static volatile LONG ptyCounter;
 
-static pty_baton* get_pty_baton(int id) {
+static pty_baton *get_pty_baton(int id) {
   for (size_t i = 0; i < ptyHandles.size(); ++i) {
-    pty_baton* ptyHandle = ptyHandles[i];
+    pty_baton *ptyHandle = ptyHandles[i];
     if (ptyHandle->id == id) {
       return ptyHandle;
     }
@@ -68,10 +73,11 @@ static pty_baton* get_pty_baton(int id) {
 
 template <typename T>
 std::vector<T> vectorFromString(const std::basic_string<T> &str) {
-    return std::vector<T>(str.begin(), str.end());
+  return std::vector<T>(str.begin(), str.end());
 }
 
-void throwNanError(const Nan::FunctionCallbackInfo<v8::Value>* info, const char* text, const bool getLastError) {
+void throwNanError(const Nan::FunctionCallbackInfo<v8::Value> *info,
+                   const char *text, const bool getLastError) {
   std::stringstream errorText;
   errorText << text;
   if (getLastError) {
@@ -82,69 +88,59 @@ void throwNanError(const Nan::FunctionCallbackInfo<v8::Value>* info, const char*
 }
 
 // Returns a new server named pipe.  It has not yet been connected.
-bool createDataServerPipe(bool write,
-                          std::wstring kind,
-                          HANDLE* hServer,
-                          std::wstring &name,
-                          const std::wstring &pipeName)
-{
+bool createDataServerPipe(bool write, std::wstring kind, HANDLE *hServer,
+                          std::wstring &name, const std::wstring &pipeName) {
   *hServer = INVALID_HANDLE_VALUE;
 
   name = L"\\\\.\\pipe\\" + pipeName + L"-" + kind;
 
-  const DWORD winOpenMode =  PIPE_ACCESS_INBOUND | PIPE_ACCESS_OUTBOUND | FILE_FLAG_FIRST_PIPE_INSTANCE/*  | FILE_FLAG_OVERLAPPED */;
+  const DWORD winOpenMode =
+      PIPE_ACCESS_INBOUND | PIPE_ACCESS_OUTBOUND |
+      FILE_FLAG_FIRST_PIPE_INSTANCE /*  | FILE_FLAG_OVERLAPPED */;
 
   SECURITY_ATTRIBUTES sa = {};
   sa.nLength = sizeof(sa);
 
-  *hServer = CreateNamedPipeW(
-      name.c_str(),
-      /*dwOpenMode=*/winOpenMode,
-      /*dwPipeMode=*/PIPE_TYPE_BYTE | PIPE_READMODE_BYTE | PIPE_WAIT,
-      /*nMaxInstances=*/1,
-      /*nOutBufferSize=*/0,
-      /*nInBufferSize=*/0,
-      /*nDefaultTimeOut=*/30000,
-      &sa);
+  *hServer = CreateNamedPipeW(name.c_str(),
+                              /*dwOpenMode=*/winOpenMode,
+                              /*dwPipeMode=*/PIPE_TYPE_BYTE |
+                                  PIPE_READMODE_BYTE | PIPE_WAIT,
+                              /*nMaxInstances=*/1,
+                              /*nOutBufferSize=*/0,
+                              /*nInBufferSize=*/0,
+                              /*nDefaultTimeOut=*/30000, &sa);
 
   return *hServer != INVALID_HANDLE_VALUE;
 }
 
-HRESULT CreateNamedPipesAndPseudoConsole(COORD size,
-                                         DWORD dwFlags,
-                                         HANDLE *phInput,
-                                         HANDLE *phOutput,
-                                         HPCON* phPC,
-                                         std::wstring& inName,
-                                         std::wstring& outName,
-                                         const std::wstring& pipeName)
-{
+HRESULT CreateNamedPipesAndPseudoConsole(COORD size, DWORD dwFlags,
+                                         HANDLE *phInput, HANDLE *phOutput,
+                                         HPCON *phPC, std::wstring &inName,
+                                         std::wstring &outName,
+                                         const std::wstring &pipeName) {
   HANDLE hLibrary = LoadLibraryExW(L"kernel32.dll", 0, 0);
   bool fLoadedDll = hLibrary != nullptr;
-  if (fLoadedDll)
-  {
-    PFNCREATEPSEUDOCONSOLE const pfnCreate = (PFNCREATEPSEUDOCONSOLE)GetProcAddress((HMODULE)hLibrary, "CreatePseudoConsole");
-    if (pfnCreate)
-    {
-      if (phPC == NULL || phInput == NULL || phOutput == NULL)
-      {
+  if (fLoadedDll) {
+    PFNCREATEPSEUDOCONSOLE const pfnCreate =
+        (PFNCREATEPSEUDOCONSOLE)GetProcAddress((HMODULE)hLibrary,
+                                               "CreatePseudoConsole");
+    if (pfnCreate) {
+      if (phPC == NULL || phInput == NULL || phOutput == NULL) {
         return E_INVALIDARG;
       }
 
-      bool success = createDataServerPipe(true, L"in", phInput, inName, pipeName);
-      if (!success)
-      {
+      bool success =
+          createDataServerPipe(true, L"in", phInput, inName, pipeName);
+      if (!success) {
         return HRESULT_FROM_WIN32(GetLastError());
       }
-      success = createDataServerPipe(false, L"out", phOutput, outName, pipeName);
-      if (!success)
-      {
+      success =
+          createDataServerPipe(false, L"out", phOutput, outName, pipeName);
+      if (!success) {
         return HRESULT_FROM_WIN32(GetLastError());
       }
       return pfnCreate(size, *phInput, *phOutput, dwFlags, phPC);
-    }
-    else
-    {
+    } else {
       // Failed to find CreatePseudoConsole in kernel32. This is likely because
       //    the user is not running a build of Windows that supports that API.
       //    We should fall back to winpty in this case.
@@ -153,7 +149,8 @@ HRESULT CreateNamedPipesAndPseudoConsole(COORD size,
   }
 
   // Failed to find  kernel32. This is realy unlikely - honestly no idea how
-  //    this is even possible to hit. But if it does happen, fall back to winpty.
+  //    this is even possible to hit. But if it does happen, fall back to
+  //    winpty.
   return HRESULT_FROM_WIN32(GetLastError());
 }
 
@@ -166,14 +163,11 @@ static NAN_METHOD(PtyStartProcess) {
   std::unique_ptr<wchar_t[]> mutableCommandline;
   PROCESS_INFORMATION _piClient{};
 
-  if (info.Length() != 6 ||
-      !info[0]->IsString() ||
-      !info[1]->IsNumber() ||
-      !info[2]->IsNumber() ||
-      !info[3]->IsBoolean() ||
-      !info[4]->IsString() ||
+  if (info.Length() != 6 || !info[0]->IsString() || !info[1]->IsNumber() ||
+      !info[2]->IsNumber() || !info[3]->IsBoolean() || !info[4]->IsString() ||
       !info[5]->IsBoolean()) {
-    Nan::ThrowError("Usage: pty.startProcess(file, cols, rows, debug, pipeName, inheritCursor)");
+    Nan::ThrowError("Usage: pty.startProcess(file, cols, rows, debug, "
+                    "pipeName, inheritCursor)");
     return;
   }
 
@@ -204,7 +198,9 @@ static NAN_METHOD(PtyStartProcess) {
 
   HANDLE hIn, hOut;
   HPCON hpc;
-  HRESULT hr = CreateNamedPipesAndPseudoConsole({cols, rows}, inheritCursor ? 1/*PSEUDOCONSOLE_INHERIT_CURSOR*/ : 0, &hIn, &hOut, &hpc, inName, outName, pipeName);
+  HRESULT hr = CreateNamedPipesAndPseudoConsole(
+      {cols, rows}, inheritCursor ? 1 /*PSEUDOCONSOLE_INHERIT_CURSOR*/ : 0,
+      &hIn, &hOut, &hpc, inName, outName, pipeName);
 
   // Restore default handling of ctrl+c
   SetConsoleCtrlHandler(NULL, FALSE);
@@ -215,28 +211,31 @@ static NAN_METHOD(PtyStartProcess) {
   if (SUCCEEDED(hr)) {
     // We were able to instantiate a conpty
     const int ptyId = InterlockedIncrement(&ptyCounter);
-    Nan::Set(marshal, Nan::New<v8::String>("pty").ToLocalChecked(), Nan::New<v8::Number>(ptyId));
+    Nan::Set(marshal, Nan::New<v8::String>("pty").ToLocalChecked(),
+             Nan::New<v8::Number>(ptyId));
     ptyHandles.insert(ptyHandles.end(), new pty_baton(ptyId, hIn, hOut, hpc));
   } else {
     Nan::ThrowError("Cannot launch conpty");
     return;
   }
 
-  Nan::Set(marshal, Nan::New<v8::String>("fd").ToLocalChecked(), Nan::New<v8::Number>(-1));
+  Nan::Set(marshal, Nan::New<v8::String>("fd").ToLocalChecked(),
+           Nan::New<v8::Number>(-1));
   {
     std::string coninPipeNameStr(inName.begin(), inName.end());
-    Nan::Set(marshal, Nan::New<v8::String>("conin").ToLocalChecked(), Nan::New<v8::String>(coninPipeNameStr).ToLocalChecked());
+    Nan::Set(marshal, Nan::New<v8::String>("conin").ToLocalChecked(),
+             Nan::New<v8::String>(coninPipeNameStr).ToLocalChecked());
 
     std::string conoutPipeNameStr(outName.begin(), outName.end());
-    Nan::Set(marshal, Nan::New<v8::String>("conout").ToLocalChecked(), Nan::New<v8::String>(conoutPipeNameStr).ToLocalChecked());
+    Nan::Set(marshal, Nan::New<v8::String>("conout").ToLocalChecked(),
+             Nan::New<v8::String>(conoutPipeNameStr).ToLocalChecked());
   }
   info.GetReturnValue().Set(marshal);
 }
 
-VOID CALLBACK OnProcessExitWinEvent(
-    _In_ PVOID context,
-    _In_ BOOLEAN TimerOrWaitFired) {
-  pty_baton *baton = static_cast<pty_baton*>(context);
+VOID CALLBACK OnProcessExitWinEvent(_In_ PVOID context,
+                                    _In_ BOOLEAN TimerOrWaitFired) {
+  pty_baton *baton = static_cast<pty_baton *>(context);
 
   // Fire OnProcessExit
   uv_async_send(&baton->async);
@@ -244,7 +243,7 @@ VOID CALLBACK OnProcessExitWinEvent(
 
 static void OnProcessExit(uv_async_t *async) {
   Nan::HandleScope scope;
-  pty_baton *baton = static_cast<pty_baton*>(async->data);
+  pty_baton *baton = static_cast<pty_baton *>(async->data);
 
   UnregisterWait(baton->hWait);
 
@@ -253,9 +252,7 @@ static void OnProcessExit(uv_async_t *async) {
   GetExitCodeProcess(baton->hShell, &exitCode);
 
   // Call function
-  v8::Local<v8::Value> args[1] = {
-    Nan::New<v8::Number>(exitCode)
-  };
+  v8::Local<v8::Value> args[1] = {Nan::New<v8::Number>(exitCode)};
 
   Nan::AsyncResource asyncResource("node-pty.callback");
   baton->cb.Call(1, args, &asyncResource);
@@ -273,12 +270,8 @@ static NAN_METHOD(PtyConnect) {
   std::stringstream errorText;
   BOOL fSuccess = FALSE;
 
-  if (info.Length() != 5 ||
-      !info[0]->IsNumber() ||
-      !info[1]->IsString() ||
-      !info[2]->IsString() ||
-      !info[3]->IsArray() ||
-      !info[4]->IsFunction()) {
+  if (info.Length() != 5 || !info[0]->IsNumber() || !info[1]->IsString() ||
+      !info[2]->IsString() || !info[3]->IsArray() || !info[4]->IsFunction()) {
     Nan::ThrowError("Usage: pty.connect(id, cmdline, cwd, env, exitCallback)");
     return;
   }
@@ -287,22 +280,27 @@ static NAN_METHOD(PtyConnect) {
   const std::wstring cmdline(path_util::to_wstring(Nan::Utf8String(info[1])));
   const std::wstring cwd(path_util::to_wstring(Nan::Utf8String(info[2])));
   const v8::Local<v8::Array> envValues = info[3].As<v8::Array>();
-  const v8::Local<v8::Function> exitCallback = v8::Local<v8::Function>::Cast(info[4]);
+  const v8::Local<v8::Function> exitCallback =
+      v8::Local<v8::Function>::Cast(info[4]);
 
   // Prepare command line
-  std::unique_ptr<wchar_t[]> mutableCommandline = std::make_unique<wchar_t[]>(cmdline.length() + 1);
-  HRESULT hr = StringCchCopyW(mutableCommandline.get(), cmdline.length() + 1, cmdline.c_str());
+  std::unique_ptr<wchar_t[]> mutableCommandline =
+      std::make_unique<wchar_t[]>(cmdline.length() + 1);
+  HRESULT hr = StringCchCopyW(mutableCommandline.get(), cmdline.length() + 1,
+                              cmdline.c_str());
 
   // Prepare cwd
-  std::unique_ptr<wchar_t[]> mutableCwd = std::make_unique<wchar_t[]>(cwd.length() + 1);
+  std::unique_ptr<wchar_t[]> mutableCwd =
+      std::make_unique<wchar_t[]>(cwd.length() + 1);
   hr = StringCchCopyW(mutableCwd.get(), cwd.length() + 1, cwd.c_str());
 
   // Prepare environment
   std::wstring env;
   if (!envValues.IsEmpty()) {
     std::wstringstream envBlock;
-    for(uint32_t i = 0; i < envValues->Length(); i++) {
-      std::wstring envValue(path_util::to_wstring(Nan::Utf8String(Nan::Get(envValues, i).ToLocalChecked())));
+    for (uint32_t i = 0; i < envValues->Length(); i++) {
+      std::wstring envValue(path_util::to_wstring(
+          Nan::Utf8String(Nan::Get(envValues, i).ToLocalChecked())));
       envBlock << envValue << L'\0';
     }
     envBlock << L'\0';
@@ -312,7 +310,7 @@ static NAN_METHOD(PtyConnect) {
   LPWSTR envArg = envV.empty() ? nullptr : envV.data();
 
   // Fetch pty handle from ID and start process
-  pty_baton* handle = get_pty_baton(id);
+  pty_baton *handle = get_pty_baton(id);
 
   BOOL success = ConnectNamedPipe(handle->hIn, nullptr);
   success = ConnectNamedPipe(handle->hOut, nullptr);
@@ -328,35 +326,34 @@ static NAN_METHOD(PtyConnect) {
   SIZE_T size = 0;
   InitializeProcThreadAttributeList(NULL, 1, 0, &size);
   BYTE *attrList = new BYTE[size];
-  siEx.lpAttributeList = reinterpret_cast<PPROC_THREAD_ATTRIBUTE_LIST>(attrList);
+  siEx.lpAttributeList =
+      reinterpret_cast<PPROC_THREAD_ATTRIBUTE_LIST>(attrList);
 
-  fSuccess = InitializeProcThreadAttributeList(siEx.lpAttributeList, 1, 0, &size);
+  fSuccess =
+      InitializeProcThreadAttributeList(siEx.lpAttributeList, 1, 0, &size);
   if (!fSuccess) {
-    return throwNanError(&info, "InitializeProcThreadAttributeList failed", true);
+    return throwNanError(&info, "InitializeProcThreadAttributeList failed",
+                         true);
   }
-  fSuccess = UpdateProcThreadAttribute(siEx.lpAttributeList,
-                                       0,
+  fSuccess = UpdateProcThreadAttribute(siEx.lpAttributeList, 0,
                                        PROC_THREAD_ATTRIBUTE_PSEUDOCONSOLE,
-                                       handle->hpc,
-                                       sizeof(HPCON),
-                                       NULL,
-                                       NULL);
+                                       handle->hpc, sizeof(HPCON), NULL, NULL);
   if (!fSuccess) {
     return throwNanError(&info, "UpdateProcThreadAttribute failed", true);
   }
 
   PROCESS_INFORMATION piClient{};
   fSuccess = !!CreateProcessW(
-      nullptr,
-      mutableCommandline.get(),
-      nullptr,                      // lpProcessAttributes
-      nullptr,                      // lpThreadAttributes
-      false,                        // bInheritHandles VERY IMPORTANT that this is false
-      EXTENDED_STARTUPINFO_PRESENT | CREATE_UNICODE_ENVIRONMENT, // dwCreationFlags
-      envArg,                       // lpEnvironment
-      mutableCwd.get(),             // lpCurrentDirectory
-      &siEx.StartupInfo,            // lpStartupInfo
-      &piClient                     // lpProcessInformation
+      nullptr, mutableCommandline.get(),
+      nullptr, // lpProcessAttributes
+      nullptr, // lpThreadAttributes
+      false,   // bInheritHandles VERY IMPORTANT that this is false
+      EXTENDED_STARTUPINFO_PRESENT |
+          CREATE_UNICODE_ENVIRONMENT, // dwCreationFlags
+      envArg,                         // lpEnvironment
+      mutableCwd.get(),               // lpCurrentDirectory
+      &siEx.StartupInfo,              // lpStartupInfo
+      &piClient                       // lpProcessInformation
   );
   if (!fSuccess) {
     return throwNanError(&info, "Cannot create process", true);
@@ -371,20 +368,21 @@ static NAN_METHOD(PtyConnect) {
   uv_async_init(uv_default_loop(), &handle->async, OnProcessExit);
 
   // Setup Windows wait for process exit event
-  RegisterWaitForSingleObject(&handle->hWait, piClient.hProcess, OnProcessExitWinEvent, (PVOID)handle, INFINITE, WT_EXECUTEONLYONCE);
+  RegisterWaitForSingleObject(&handle->hWait, piClient.hProcess,
+                              OnProcessExitWinEvent, (PVOID)handle, INFINITE,
+                              WT_EXECUTEONLYONCE);
 
   // Return
   v8::Local<v8::Object> marshal = Nan::New<v8::Object>();
-  Nan::Set(marshal, Nan::New<v8::String>("pid").ToLocalChecked(), Nan::New<v8::Number>(piClient.dwProcessId));
+  Nan::Set(marshal, Nan::New<v8::String>("pid").ToLocalChecked(),
+           Nan::New<v8::Number>(piClient.dwProcessId));
   info.GetReturnValue().Set(marshal);
 }
 
 static NAN_METHOD(PtyResize) {
   Nan::HandleScope scope;
 
-  if (info.Length() != 3 ||
-      !info[0]->IsNumber() ||
-      !info[1]->IsNumber() ||
+  if (info.Length() != 3 || !info[0]->IsNumber() || !info[1]->IsNumber() ||
       !info[2]->IsNumber()) {
     Nan::ThrowError("Usage: pty.resize(id, cols, rows)");
     return;
@@ -394,15 +392,15 @@ static NAN_METHOD(PtyResize) {
   SHORT cols = info[1]->Uint32Value(Nan::GetCurrentContext()).FromJust();
   SHORT rows = info[2]->Uint32Value(Nan::GetCurrentContext()).FromJust();
 
-  const pty_baton* handle = get_pty_baton(id);
+  const pty_baton *handle = get_pty_baton(id);
 
   HANDLE hLibrary = LoadLibraryExW(L"kernel32.dll", 0, 0);
   bool fLoadedDll = hLibrary != nullptr;
-  if (fLoadedDll)
-  {
-    PFNRESIZEPSEUDOCONSOLE const pfnResizePseudoConsole = (PFNRESIZEPSEUDOCONSOLE)GetProcAddress((HMODULE)hLibrary, "ResizePseudoConsole");
-    if (pfnResizePseudoConsole)
-    {
+  if (fLoadedDll) {
+    PFNRESIZEPSEUDOCONSOLE const pfnResizePseudoConsole =
+        (PFNRESIZEPSEUDOCONSOLE)GetProcAddress((HMODULE)hLibrary,
+                                               "ResizePseudoConsole");
+    if (pfnResizePseudoConsole) {
       COORD size = {cols, rows};
       pfnResizePseudoConsole(handle->hpc, size);
     }
@@ -414,23 +412,22 @@ static NAN_METHOD(PtyResize) {
 static NAN_METHOD(PtyKill) {
   Nan::HandleScope scope;
 
-  if (info.Length() != 1 ||
-      !info[0]->IsNumber()) {
+  if (info.Length() != 1 || !info[0]->IsNumber()) {
     Nan::ThrowError("Usage: pty.kill(id)");
     return;
   }
 
   int id = info[0]->Int32Value(Nan::GetCurrentContext()).FromJust();
 
-  const pty_baton* handle = get_pty_baton(id);
+  const pty_baton *handle = get_pty_baton(id);
 
   HANDLE hLibrary = LoadLibraryExW(L"kernel32.dll", 0, 0);
   bool fLoadedDll = hLibrary != nullptr;
-  if (fLoadedDll)
-  {
-    PFNCLOSEPSEUDOCONSOLE const pfnClosePseudoConsole = (PFNCLOSEPSEUDOCONSOLE)GetProcAddress((HMODULE)hLibrary, "ClosePseudoConsole");
-    if (pfnClosePseudoConsole)
-    {
+  if (fLoadedDll) {
+    PFNCLOSEPSEUDOCONSOLE const pfnClosePseudoConsole =
+        (PFNCLOSEPSEUDOCONSOLE)GetProcAddress((HMODULE)hLibrary,
+                                              "ClosePseudoConsole");
+    if (pfnClosePseudoConsole) {
       pfnClosePseudoConsole(handle->hpc);
     }
   }
@@ -441,8 +438,8 @@ static NAN_METHOD(PtyKill) {
 }
 
 /**
-* Init
-*/
+ * Init
+ */
 
 extern "C" void init(v8::Local<v8::Object> target) {
   Nan::HandleScope scope;
diff --git a/addons/godot_xterm/native/src/node_pty/win/conpty_console_list.cc b/addons/godot_xterm/native/src/node_pty/win/conpty_console_list.cc
index be135ba..889cff4 100644
--- a/addons/godot_xterm/native/src/node_pty/win/conpty_console_list.cc
+++ b/addons/godot_xterm/native/src/node_pty/win/conpty_console_list.cc
@@ -6,8 +6,7 @@
 #include <windows.h>
 
 static NAN_METHOD(ApiConsoleProcessList) {
-  if (info.Length() != 1 ||
-      !info[0]->IsNumber()) {
+  if (info.Length() != 1 || !info[0]->IsNumber()) {
     Nan::ThrowError("Usage: getConsoleProcessList(shellPid)");
     return;
   }
@@ -21,10 +20,11 @@ static NAN_METHOD(ApiConsoleProcessList) {
     Nan::ThrowError("AttachConsole failed");
   }
   auto processList = std::vector<DWORD>(64);
-  auto processCount = GetConsoleProcessList(&processList[0], processList.size());
+  auto processCount =
+      GetConsoleProcessList(&processList[0], processList.size());
   if (processList.size() < processCount) {
-      processList.resize(processCount);
-      processCount = GetConsoleProcessList(&processList[0], processList.size());
+    processList.resize(processCount);
+    processCount = GetConsoleProcessList(&processList[0], processList.size());
   }
   FreeConsole();
 
diff --git a/addons/godot_xterm/native/src/node_pty/win/path_util.cc b/addons/godot_xterm/native/src/node_pty/win/path_util.cc
index 4e69f30..128af22 100644
--- a/addons/godot_xterm/native/src/node_pty/win/path_util.cc
+++ b/addons/godot_xterm/native/src/node_pty/win/path_util.cc
@@ -4,14 +4,14 @@
  * Copyright (c) 2018, Microsoft Corporation (MIT License).
  */
 
-#include <nan.h>
 #include <Shlwapi.h> // PathCombine
+#include <nan.h>
 
 #include "path_util.h"
 
 namespace path_util {
 
-const wchar_t* to_wstring(const Nan::Utf8String& str) {
+const wchar_t *to_wstring(const Nan::Utf8String &str) {
   const char *bytes = *str;
   unsigned int sizeOfStr = MultiByteToWideChar(CP_UTF8, 0, bytes, -1, NULL, 0);
   wchar_t *output = new wchar_t[sizeOfStr];
@@ -55,7 +55,7 @@ std::wstring get_shell_path(std::wstring filename) {
   for (int i = 0; i < paths.size(); ++i) {
     std::wstring path = paths[i];
     wchar_t searchPath[MAX_PATH];
-    ::PathCombineW(searchPath, const_cast<wchar_t*>(path.c_str()), filename_);
+    ::PathCombineW(searchPath, const_cast<wchar_t *>(path.c_str()), filename_);
 
     if (searchPath == NULL) {
       continue;
@@ -70,4 +70,4 @@ std::wstring get_shell_path(std::wstring filename) {
   return shellpath;
 }
 
-}  // namespace path_util
+} // namespace path_util
diff --git a/addons/godot_xterm/native/src/node_pty/win/path_util.h b/addons/godot_xterm/native/src/node_pty/win/path_util.h
index 8dd58d2..db8d3cd 100644
--- a/addons/godot_xterm/native/src/node_pty/win/path_util.h
+++ b/addons/godot_xterm/native/src/node_pty/win/path_util.h
@@ -13,10 +13,10 @@
 
 namespace path_util {
 
-const wchar_t* to_wstring(const Nan::Utf8String& str);
+const wchar_t *to_wstring(const Nan::Utf8String &str);
 bool file_exists(std::wstring filename);
 std::wstring get_shell_path(std::wstring filename);
 
-}  // namespace path_util
+} // namespace path_util
 
-#endif  // NODE_PTY_PATH_UTIL_H_
+#endif // NODE_PTY_PATH_UTIL_H_
diff --git a/addons/godot_xterm/native/src/node_pty/win/winpty.cc b/addons/godot_xterm/native/src/node_pty/win/winpty.cc
index b054dee..f3165ad 100644
--- a/addons/godot_xterm/native/src/node_pty/win/winpty.cc
+++ b/addons/godot_xterm/native/src/node_pty/win/winpty.cc
@@ -8,9 +8,9 @@
  *   with pseudo-terminal file descriptors.
  */
 
+#include <Shlwapi.h> // PathCombine, PathIsRelative
 #include <iostream>
 #include <nan.h>
-#include <Shlwapi.h> // PathCombine, PathIsRelative
 #include <sstream>
 #include <stdlib.h>
 #include <string.h>
@@ -21,21 +21,21 @@
 #include "path_util.h"
 
 /**
-* Misc
-*/
+ * Misc
+ */
 extern "C" void init(v8::Local<v8::Object>);
 
 #define WINPTY_DBG_VARIABLE TEXT("WINPTYDBG")
 
 /**
-* winpty
-*/
+ * winpty
+ */
 static std::vector<winpty_t *> ptyHandles;
 static volatile LONG ptyCounter;
 
 /**
-* Helpers
-*/
+ * Helpers
+ */
 
 static winpty_t *get_pipe_handle(int handle) {
   for (size_t i = 0; i < ptyHandles.size(); ++i) {
@@ -73,14 +73,15 @@ void throw_winpty_error(const char *generalMsg, winpty_error_ptr_t error_ptr) {
 static NAN_METHOD(PtyGetExitCode) {
   Nan::HandleScope scope;
 
-  if (info.Length() != 1 ||
-      !info[0]->IsNumber()) {
+  if (info.Length() != 1 || !info[0]->IsNumber()) {
     Nan::ThrowError("Usage: pty.getExitCode(pidHandle)");
     return;
   }
 
   DWORD exitCode = 0;
-  GetExitCodeProcess((HANDLE)info[0]->IntegerValue(Nan::GetCurrentContext()).FromJust(), &exitCode);
+  GetExitCodeProcess(
+      (HANDLE)info[0]->IntegerValue(Nan::GetCurrentContext()).FromJust(),
+      &exitCode);
 
   info.GetReturnValue().Set(Nan::New<v8::Number>(exitCode));
 }
@@ -88,8 +89,7 @@ static NAN_METHOD(PtyGetExitCode) {
 static NAN_METHOD(PtyGetProcessList) {
   Nan::HandleScope scope;
 
-  if (info.Length() != 1 ||
-      !info[0]->IsNumber()) {
+  if (info.Length() != 1 || !info[0]->IsNumber()) {
     Nan::ThrowError("Usage: pty.getProcessList(pid)");
     return;
   }
@@ -103,7 +103,8 @@ static NAN_METHOD(PtyGetProcessList) {
   }
   int processList[64];
   const int processCount = 64;
-  int actualCount = winpty_get_console_process_list(pc, processList, processCount, nullptr);
+  int actualCount =
+      winpty_get_console_process_list(pc, processList, processCount, nullptr);
 
   v8::Local<v8::Array> result = Nan::New<v8::Array>(actualCount);
   for (uint32_t i = 0; i < actualCount; i++) {
@@ -115,15 +116,11 @@ static NAN_METHOD(PtyGetProcessList) {
 static NAN_METHOD(PtyStartProcess) {
   Nan::HandleScope scope;
 
-  if (info.Length() != 7 ||
-      !info[0]->IsString() ||
-      !info[1]->IsString() ||
-      !info[2]->IsArray() ||
-      !info[3]->IsString() ||
-      !info[4]->IsNumber() ||
-      !info[5]->IsNumber() ||
-      !info[6]->IsBoolean()) {
-    Nan::ThrowError("Usage: pty.startProcess(file, cmdline, env, cwd, cols, rows, debug)");
+  if (info.Length() != 7 || !info[0]->IsString() || !info[1]->IsString() ||
+      !info[2]->IsArray() || !info[3]->IsString() || !info[4]->IsNumber() ||
+      !info[5]->IsNumber() || !info[6]->IsBoolean()) {
+    Nan::ThrowError(
+        "Usage: pty.startProcess(file, cmdline, env, cwd, cols, rows, debug)");
     return;
   }
 
@@ -140,8 +137,9 @@ static NAN_METHOD(PtyStartProcess) {
 
     std::wstringstream envBlock;
 
-    for(uint32_t i = 0; i < envValues->Length(); i++) {
-      std::wstring envValue(path_util::to_wstring(Nan::Utf8String(Nan::Get(envValues, i).ToLocalChecked())));
+    for (uint32_t i = 0; i < envValues->Length(); i++) {
+      std::wstring envValue(path_util::to_wstring(
+          Nan::Utf8String(Nan::Get(envValues, i).ToLocalChecked())));
       envBlock << envValue << L'\0';
     }
 
@@ -170,11 +168,12 @@ static NAN_METHOD(PtyStartProcess) {
   bool debug = Nan::To<bool>(info[6]).FromJust();
 
   // Enable/disable debugging
-  SetEnvironmentVariable(WINPTY_DBG_VARIABLE, debug ? "1" : NULL); // NULL = deletes variable
+  SetEnvironmentVariable(WINPTY_DBG_VARIABLE,
+                         debug ? "1" : NULL); // NULL = deletes variable
 
   // Create winpty config
   winpty_error_ptr_t error_ptr = nullptr;
-  winpty_config_t* winpty_config = winpty_config_new(0, &error_ptr);
+  winpty_config_t *winpty_config = winpty_config_new(0, &error_ptr);
   if (winpty_config == nullptr) {
     throw_winpty_error("Error creating WinPTY config", error_ptr);
     goto cleanup;
@@ -197,7 +196,9 @@ static NAN_METHOD(PtyStartProcess) {
   ptyHandles.insert(ptyHandles.end(), pc);
 
   // Create winpty spawn config
-  winpty_spawn_config_t* config = winpty_spawn_config_new(WINPTY_SPAWN_FLAG_AUTO_SHUTDOWN, shellpath.c_str(), cmdline, cwd, env.c_str(), &error_ptr);
+  winpty_spawn_config_t *config = winpty_spawn_config_new(
+      WINPTY_SPAWN_FLAG_AUTO_SHUTDOWN, shellpath.c_str(), cmdline, cwd,
+      env.c_str(), &error_ptr);
   if (config == nullptr) {
     throw_winpty_error("Error creating WinPTY spawn config", error_ptr);
     goto cleanup;
@@ -206,7 +207,8 @@ static NAN_METHOD(PtyStartProcess) {
 
   // Spawn the new process
   HANDLE handle = nullptr;
-  BOOL spawnSuccess = winpty_spawn(pc, config, &handle, nullptr, nullptr, &error_ptr);
+  BOOL spawnSuccess =
+      winpty_spawn(pc, config, &handle, nullptr, nullptr, &error_ptr);
   winpty_spawn_config_free(config);
   if (!spawnSuccess) {
     throw_winpty_error("Unable to start terminal process", error_ptr);
@@ -216,20 +218,29 @@ static NAN_METHOD(PtyStartProcess) {
 
   // Set return values
   v8::Local<v8::Object> marshal = Nan::New<v8::Object>();
-  Nan::Set(marshal, Nan::New<v8::String>("innerPid").ToLocalChecked(), Nan::New<v8::Number>((int)GetProcessId(handle)));
-  Nan::Set(marshal, Nan::New<v8::String>("innerPidHandle").ToLocalChecked(), Nan::New<v8::Number>((int)handle));
-  Nan::Set(marshal, Nan::New<v8::String>("pid").ToLocalChecked(), Nan::New<v8::Number>((int)winpty_agent_process(pc)));
-  Nan::Set(marshal, Nan::New<v8::String>("pty").ToLocalChecked(), Nan::New<v8::Number>(InterlockedIncrement(&ptyCounter)));
-  Nan::Set(marshal, Nan::New<v8::String>("fd").ToLocalChecked(), Nan::New<v8::Number>(-1));
+  Nan::Set(marshal, Nan::New<v8::String>("innerPid").ToLocalChecked(),
+           Nan::New<v8::Number>((int)GetProcessId(handle)));
+  Nan::Set(marshal, Nan::New<v8::String>("innerPidHandle").ToLocalChecked(),
+           Nan::New<v8::Number>((int)handle));
+  Nan::Set(marshal, Nan::New<v8::String>("pid").ToLocalChecked(),
+           Nan::New<v8::Number>((int)winpty_agent_process(pc)));
+  Nan::Set(marshal, Nan::New<v8::String>("pty").ToLocalChecked(),
+           Nan::New<v8::Number>(InterlockedIncrement(&ptyCounter)));
+  Nan::Set(marshal, Nan::New<v8::String>("fd").ToLocalChecked(),
+           Nan::New<v8::Number>(-1));
   {
     LPCWSTR coninPipeName = winpty_conin_name(pc);
     std::wstring coninPipeNameWStr(coninPipeName);
-    std::string coninPipeNameStr(coninPipeNameWStr.begin(), coninPipeNameWStr.end());
-    Nan::Set(marshal, Nan::New<v8::String>("conin").ToLocalChecked(), Nan::New<v8::String>(coninPipeNameStr).ToLocalChecked());
+    std::string coninPipeNameStr(coninPipeNameWStr.begin(),
+                                 coninPipeNameWStr.end());
+    Nan::Set(marshal, Nan::New<v8::String>("conin").ToLocalChecked(),
+             Nan::New<v8::String>(coninPipeNameStr).ToLocalChecked());
     LPCWSTR conoutPipeName = winpty_conout_name(pc);
     std::wstring conoutPipeNameWStr(conoutPipeName);
-    std::string conoutPipeNameStr(conoutPipeNameWStr.begin(), conoutPipeNameWStr.end());
-    Nan::Set(marshal, Nan::New<v8::String>("conout").ToLocalChecked(), Nan::New<v8::String>(conoutPipeNameStr).ToLocalChecked());
+    std::string conoutPipeNameStr(conoutPipeNameWStr.begin(),
+                                  conoutPipeNameWStr.end());
+    Nan::Set(marshal, Nan::New<v8::String>("conout").ToLocalChecked(),
+             Nan::New<v8::String>(conoutPipeNameStr).ToLocalChecked());
   }
   info.GetReturnValue().Set(marshal);
 
@@ -244,9 +255,7 @@ cleanup:
 static NAN_METHOD(PtyResize) {
   Nan::HandleScope scope;
 
-  if (info.Length() != 3 ||
-      !info[0]->IsNumber() ||
-      !info[1]->IsNumber() ||
+  if (info.Length() != 3 || !info[0]->IsNumber() || !info[1]->IsNumber() ||
       !info[2]->IsNumber()) {
     Nan::ThrowError("Usage: pty.resize(pid, cols, rows)");
     return;
@@ -274,15 +283,14 @@ static NAN_METHOD(PtyResize) {
 static NAN_METHOD(PtyKill) {
   Nan::HandleScope scope;
 
-  if (info.Length() != 2 ||
-      !info[0]->IsNumber() ||
-      !info[1]->IsNumber()) {
+  if (info.Length() != 2 || !info[0]->IsNumber() || !info[1]->IsNumber()) {
     Nan::ThrowError("Usage: pty.kill(pid, innerPidHandle)");
     return;
   }
 
   int handle = info[0]->Int32Value(Nan::GetCurrentContext()).FromJust();
-  HANDLE innerPidHandle = (HANDLE)info[1]->Int32Value(Nan::GetCurrentContext()).FromJust();
+  HANDLE innerPidHandle =
+      (HANDLE)info[1]->Int32Value(Nan::GetCurrentContext()).FromJust();
 
   winpty_t *pc = get_pipe_handle(handle);
   if (pc == nullptr) {
@@ -297,8 +305,8 @@ static NAN_METHOD(PtyKill) {
 }
 
 /**
-* Init
-*/
+ * Init
+ */
 
 extern "C" void init(v8::Local<v8::Object> target) {
   Nan::HandleScope scope;