@socketsecurity/cli-with-sentry 0.15.11 → 0.15.13

package/external/blessed/lib/events.js

@@ -6,84 +6,80 @@
  * https://github.com/chjj/blessed
  */
 
-const slice = Array.prototype.slice
+var slice = Array.prototype.slice;
 
 /**
  * EventEmitter
  */
 
 function EventEmitter() {
-  if (!this._events) {
-    this._events = {}
-  }
+  if (!this._events) this._events = {};
 }
 
-EventEmitter.prototype.setMaxListeners = function (n) {
-  this._maxListeners = n
-}
+EventEmitter.prototype.setMaxListeners = function(n) {
+  this._maxListeners = n;
+};
 
-EventEmitter.prototype.addListener = function (type, listener) {
+EventEmitter.prototype.addListener = function(type, listener) {
   if (!this._events[type]) {
-    this._events[type] = listener
+    this._events[type] = listener;
   } else if (typeof this._events[type] === 'function') {
-    this._events[type] = [this._events[type], listener]
+    this._events[type] = [this._events[type], listener];
   } else {
-    this._events[type].push(listener)
+    this._events[type].push(listener);
   }
-  this._emit('newListener', [type, listener])
-}
+  this._emit('newListener', [type, listener]);
+};
 
-EventEmitter.prototype.on = EventEmitter.prototype.addListener
+EventEmitter.prototype.on = EventEmitter.prototype.addListener;
 
-EventEmitter.prototype.removeListener = function (type, listener) {
-  const handler = this._events[type]
-  if (!handler) {
-    return
-  }
+EventEmitter.prototype.removeListener = function(type, listener) {
+  var handler = this._events[type];
+  if (!handler) return;
 
   if (typeof handler === 'function' || handler.length === 1) {
-    delete this._events[type]
-    this._emit('removeListener', [type, listener])
-    return
+    delete this._events[type];
+    this._emit('removeListener', [type, listener]);
+    return;
   }
 
-  for (let i = 0; i < handler.length; i++) {
+  for (var i = 0; i < handler.length; i++) {
     if (handler[i] === listener || handler[i].listener === listener) {
-      handler.splice(i, 1)
-      this._emit('removeListener', [type, listener])
-      return
+      handler.splice(i, 1);
+      this._emit('removeListener', [type, listener]);
+      return;
     }
   }
-}
+};
 
-EventEmitter.prototype.off = EventEmitter.prototype.removeListener
+EventEmitter.prototype.off = EventEmitter.prototype.removeListener;
 
-EventEmitter.prototype.removeAllListeners = function (type) {
+EventEmitter.prototype.removeAllListeners = function(type) {
   if (type) {
-    delete this._events[type]
+    delete this._events[type];
   } else {
-    this._events = {}
+    this._events = {};
   }
-}
+};
 
-EventEmitter.prototype.once = function (type, listener) {
+EventEmitter.prototype.once = function(type, listener) {
   function on() {
-    this.removeListener(type, on)
-    return listener.apply(this, arguments)
+    this.removeListener(type, on);
+    return listener.apply(this, arguments);
   }
-  on.listener = listener
-  return this.on(type, on)
-}
+  on.listener = listener;
+  return this.on(type, on);
+};
 
-EventEmitter.prototype.listeners = function (type) {
+EventEmitter.prototype.listeners = function(type) {
   return typeof this._events[type] === 'function'
     ? [this._events[type]]
-    : this._events[type] || []
-}
+    : this._events[type] || [];
+};
 
-EventEmitter.prototype._emit = function (type, args) {
-  let handler = this._events[type],
-    ret
+EventEmitter.prototype._emit = function(type, args) {
+  var handler = this._events[type]
+    , ret;
 
   // if (type !== 'event') {
   //   this._emit('event', [type.replace(/^element /, '')].concat(args));
@@ -91,41 +87,41 @@ EventEmitter.prototype._emit = function (type, args) {
 
   if (!handler) {
     if (type === 'error') {
-      throw new args[0]()
+      throw new args[0];
     }
-    return
+    return;
   }
 
   if (typeof handler === 'function') {
-    return handler.apply(this, args)
+    return handler.apply(this, args);
   }
 
-  for (let i = 0; i < handler.length; i++) {
+  for (var i = 0; i < handler.length; i++) {
     if (handler[i].apply(this, args) === false) {
-      ret = false
+      ret = false;
     }
   }
 
-  return ret !== false
-}
+  return ret !== false;
+};
 
-EventEmitter.prototype.emit = function (type) {
-  let args = slice.call(arguments, 1),
-    params = slice.call(arguments),
-    el = this
+EventEmitter.prototype.emit = function(type) {
+  var args = slice.call(arguments, 1)
+    , params = slice.call(arguments)
+    , el = this;
 
-  this._emit('event', params)
+  this._emit('event', params);
 
   if (this.type === 'screen') {
-    return this._emit(type, args)
+    return this._emit(type, args);
   }
 
   if (this._emit(type, args) === false) {
-    return false
+    return false;
   }
 
-  type = 'element ' + type
-  args.unshift(this)
+  type = 'element ' + type;
+  args.unshift(this);
   // `element` prefix
   // params = [type].concat(args);
   // no `element` prefix
@@ -133,16 +129,14 @@ EventEmitter.prototype.emit = function (type) {
 
   do {
     // el._emit('event', params);
-    if (!el._events[type]) {
-      continue
-    }
+    if (!el._events[type]) continue;
     if (el._emit(type, args) === false) {
-      return false
+      return false;
     }
-  } while ((el = el.parent))
+  } while (el = el.parent);
 
-  return true
-}
+  return true;
+};
 
 // For hooking into the main EventEmitter if we want to.
 // Might be better to do things this way being that it
@@ -191,7 +185,7 @@ EventEmitter.prototype.emit = function (type) {
  * Expose
  */
 
-exports = EventEmitter
-exports.EventEmitter = EventEmitter
+exports = EventEmitter;
+exports.EventEmitter = EventEmitter;
 
-module.exports = exports
+module.exports = exports;

package/external/blessed/lib/gpmclient.js

@@ -6,25 +6,25 @@
  * https://github.com/chjj/blessed
  */
 
-const net = require('net')
-const fs = require('fs')
-const EventEmitter = require('events').EventEmitter
+var net = require('net');
+var fs = require('fs');
+var EventEmitter = require('events').EventEmitter;
 
-const GPM_USE_MAGIC = false
+var GPM_USE_MAGIC = false;
 
-const GPM_MOVE = 1,
-  GPM_DRAG = 2,
-  GPM_DOWN = 4,
-  GPM_UP = 8
+var GPM_MOVE = 1
+  , GPM_DRAG = 2
+  , GPM_DOWN = 4
+  , GPM_UP = 8;
 
-const GPM_DOUBLE = 32,
-  GPM_MFLAG = 128
+var GPM_DOUBLE = 32
+  , GPM_MFLAG = 128;
 
-const GPM_REQ_NOPASTE = 3,
-  GPM_HARD = 256
+var GPM_REQ_NOPASTE = 3
+  , GPM_HARD = 256;
 
-const GPM_MAGIC = 0x47706d4c
-const GPM_SOCKET = '/dev/gpmctl'
+var GPM_MAGIC = 0x47706D4C;
+var GPM_SOCKET = '/dev/gpmctl';
 
 // typedef struct Gpm_Connect {
 //   unsigned short eventMask, defaultMask;
@@ -33,31 +33,29 @@ const GPM_SOCKET = '/dev/gpmctl'
 //   int vc;
 // } Gpm_Connect;
 
-function send_config(socket, Gpm_Connect, callback) {
-  let buffer
+function send_config(socket, Gpm_Connect,  callback) {
+  var buffer;
   if (GPM_USE_MAGIC) {
-    buffer = new Buffer(20)
-    buffer.writeUInt32LE(GPM_MAGIC, 0)
-    buffer.writeUInt16LE(Gpm_Connect.eventMask, 4)
-    buffer.writeUInt16LE(Gpm_Connect.defaultMask, 6)
-    buffer.writeUInt16LE(Gpm_Connect.minMod, 8)
-    buffer.writeUInt16LE(Gpm_Connect.maxMod, 10)
-    buffer.writeInt16LE(process.pid, 12)
-    buffer.writeInt16LE(Gpm_Connect.vc, 16)
+    buffer = new Buffer(20);
+    buffer.writeUInt32LE(GPM_MAGIC, 0);
+    buffer.writeUInt16LE(Gpm_Connect.eventMask, 4);
+    buffer.writeUInt16LE(Gpm_Connect.defaultMask, 6);
+    buffer.writeUInt16LE(Gpm_Connect.minMod, 8);
+    buffer.writeUInt16LE(Gpm_Connect.maxMod, 10);
+    buffer.writeInt16LE(process.pid, 12);
+    buffer.writeInt16LE(Gpm_Connect.vc, 16);
   } else {
-    buffer = new Buffer(16)
-    buffer.writeUInt16LE(Gpm_Connect.eventMask, 0)
-    buffer.writeUInt16LE(Gpm_Connect.defaultMask, 2)
-    buffer.writeUInt16LE(Gpm_Connect.minMod, 4)
-    buffer.writeUInt16LE(Gpm_Connect.maxMod, 6)
-    buffer.writeInt16LE(Gpm_Connect.pid, 8)
-    buffer.writeInt16LE(Gpm_Connect.vc, 12)
+    buffer = new Buffer(16);
+    buffer.writeUInt16LE(Gpm_Connect.eventMask, 0);
+    buffer.writeUInt16LE(Gpm_Connect.defaultMask, 2);
+    buffer.writeUInt16LE(Gpm_Connect.minMod, 4);
+    buffer.writeUInt16LE(Gpm_Connect.maxMod, 6);
+    buffer.writeInt16LE(Gpm_Connect.pid, 8);
+    buffer.writeInt16LE(Gpm_Connect.vc, 12);
   }
-  socket.write(buffer, function () {
-    if (callback) {
-      callback()
-    }
-  })
+  socket.write(buffer, function() {
+    if (callback) callback();
+  });
 }
 
 // typedef struct Gpm_Event {
@@ -78,170 +76,148 @@ function send_config(socket, Gpm_Connect, callback) {
 // } Gpm_Event;
 
 function parseEvent(raw) {
-  const evnt = {}
-  evnt.buttons = raw[0]
-  evnt.modifiers = raw[1]
-  evnt.vc = raw.readUInt16LE(2)
-  evnt.dx = raw.readInt16LE(4)
-  evnt.dy = raw.readInt16LE(6)
-  evnt.x = raw.readInt16LE(8)
-  evnt.y = raw.readInt16LE(10)
-  evnt.type = raw.readInt16LE(12)
-  evnt.clicks = raw.readInt32LE(16)
-  evnt.margin = raw.readInt32LE(20)
-  evnt.wdx = raw.readInt16LE(24)
-  evnt.wdy = raw.readInt16LE(26)
-  return evnt
+  var evnt = {};
+  evnt.buttons = raw[0];
+  evnt.modifiers = raw[1];
+  evnt.vc = raw.readUInt16LE(2);
+  evnt.dx = raw.readInt16LE(4);
+  evnt.dy = raw.readInt16LE(6);
+  evnt.x = raw.readInt16LE(8);
+  evnt.y = raw.readInt16LE(10);
+  evnt.type = raw.readInt16LE(12);
+  evnt.clicks = raw.readInt32LE(16);
+  evnt.margin = raw.readInt32LE(20);
+  evnt.wdx = raw.readInt16LE(24);
+  evnt.wdy = raw.readInt16LE(26);
+  return evnt;
 }
 
 function GpmClient(options) {
   if (!(this instanceof GpmClient)) {
-    return new GpmClient(options)
+    return new GpmClient(options);
   }
 
-  EventEmitter.call(this)
+  EventEmitter.call(this);
 
-  const pid = process.pid
+  var pid = process.pid;
 
   // check tty for /dev/tty[n]
-  let path
+  var path;
   try {
-    path = fs.readlinkSync('/proc/' + pid + '/fd/0')
-  } catch (e) {}
-  let tty = /tty[0-9]+$/.exec(path)
+    path = fs.readlinkSync('/proc/' + pid + '/fd/0');
+  } catch (e) {
+    ;
+  }
+  var tty = /tty[0-9]+$/.exec(path);
   if (tty === null) {
     // TODO: should  also check for /dev/input/..
   }
 
-  let vc
+  var vc;
   if (tty) {
-    tty = tty[0]
-    vc = +/[0-9]+$/.exec(tty)[0]
+    tty = tty[0];
+    vc = +/[0-9]+$/.exec(tty)[0];
   }
 
-  const self = this
+  var self = this;
 
   if (tty) {
-    fs.stat(GPM_SOCKET, function (err, stat) {
+    fs.stat(GPM_SOCKET, function(err, stat) {
       if (err || !stat.isSocket()) {
-        return
+        return;
       }
 
-      const conf = {
+      var conf =  {
         eventMask: 0xffff,
         defaultMask: GPM_MOVE | GPM_HARD,
         minMod: 0,
         maxMod: 0xffff,
         pid: pid,
         vc: vc
-      }
+      };
 
-      const gpm = net.createConnection(GPM_SOCKET)
-      this.gpm = gpm
+      var gpm = net.createConnection(GPM_SOCKET);
+      this.gpm = gpm;
 
-      gpm.on('connect', function () {
-        send_config(gpm, conf, function () {
-          conf.pid = 0
-          conf.vc = GPM_REQ_NOPASTE
+      gpm.on('connect', function() {
+        send_config(gpm, conf, function() {
+          conf.pid = 0;
+          conf.vc = GPM_REQ_NOPASTE;
           //send_config(gpm, conf);
-        })
-      })
+        });
+      });
 
-      gpm.on('data', function (packet) {
-        const evnt = parseEvent(packet)
+      gpm.on('data', function(packet) {
+        var evnt = parseEvent(packet);
         switch (evnt.type & 15) {
           case GPM_MOVE:
             if (evnt.dx || evnt.dy) {
-              self.emit('move', evnt.buttons, evnt.modifiers, evnt.x, evnt.y)
+              self.emit('move', evnt.buttons, evnt.modifiers, evnt.x, evnt.y);
             }
             if (evnt.wdx || evnt.wdy) {
-              self.emit(
-                'mousewheel',
-                evnt.buttons,
-                evnt.modifiers,
-                evnt.x,
-                evnt.y,
-                evnt.wdx,
-                evnt.wdy
-              )
+              self.emit('mousewheel',
+                evnt.buttons, evnt.modifiers,
+                evnt.x, evnt.y, evnt.wdx, evnt.wdy);
             }
-            break
+            break;
           case GPM_DRAG:
             if (evnt.dx || evnt.dy) {
-              self.emit('drag', evnt.buttons, evnt.modifiers, evnt.x, evnt.y)
+              self.emit('drag', evnt.buttons, evnt.modifiers, evnt.x, evnt.y);
             }
             if (evnt.wdx || evnt.wdy) {
-              self.emit(
-                'mousewheel',
-                evnt.buttons,
-                evnt.modifiers,
-                evnt.x,
-                evnt.y,
-                evnt.wdx,
-                evnt.wdy
-              )
+              self.emit('mousewheel',
+                evnt.buttons, evnt.modifiers,
+                evnt.x, evnt.y, evnt.wdx, evnt.wdy);
             }
-            break
+            break;
           case GPM_DOWN:
-            self.emit('btndown', evnt.buttons, evnt.modifiers, evnt.x, evnt.y)
+            self.emit('btndown', evnt.buttons, evnt.modifiers, evnt.x, evnt.y);
             if (evnt.type & GPM_DOUBLE) {
-              self.emit(
-                'dblclick',
-                evnt.buttons,
-                evnt.modifiers,
-                evnt.x,
-                evnt.y
-              )
+              self.emit('dblclick', evnt.buttons, evnt.modifiers, evnt.x, evnt.y);
             }
-            break
+            break;
           case GPM_UP:
-            self.emit('btnup', evnt.buttons, evnt.modifiers, evnt.x, evnt.y)
+            self.emit('btnup', evnt.buttons, evnt.modifiers, evnt.x, evnt.y);
             if (!(evnt.type & GPM_MFLAG)) {
-              self.emit('click', evnt.buttons, evnt.modifiers, evnt.x, evnt.y)
+              self.emit('click', evnt.buttons, evnt.modifiers, evnt.x, evnt.y);
             }
-            break
+            break;
         }
-      })
+      });
 
-      gpm.on('error', function () {
-        self.stop()
-      })
-    })
+      gpm.on('error', function() {
+        self.stop();
+      });
+    });
   }
 }
 
-Object.setPrototypeOf(GpmClient.prototype, EventEmitter.prototype)
+Object.setPrototypeOf(GpmClient.prototype, EventEmitter.prototype);
 
-GpmClient.prototype.stop = function () {
+GpmClient.prototype.stop = function() {
   if (this.gpm) {
-    this.gpm.end()
+    this.gpm.end();
   }
-  delete this.gpm
-}
+  delete this.gpm;
+};
 
-GpmClient.prototype.ButtonName = function (btn) {
-  if (btn & 4) {
-    return 'left'
-  }
-  if (btn & 2) {
-    return 'middle'
-  }
-  if (btn & 1) {
-    return 'right'
-  }
-  return ''
-}
+GpmClient.prototype.ButtonName =  function(btn) {
+  if (btn & 4) return 'left';
+  if (btn & 2) return 'middle';
+  if (btn & 1) return 'right';
+  return '';
+};
 
-GpmClient.prototype.hasShiftKey = function (mod) {
-  return mod & 1 ? true : false
-}
+GpmClient.prototype.hasShiftKey =  function(mod) {
+  return (mod & 1) ? true : false;
+};
 
-GpmClient.prototype.hasCtrlKey = function (mod) {
-  return mod & 4 ? true : false
-}
+GpmClient.prototype.hasCtrlKey =  function(mod) {
+  return (mod & 4) ? true : false;
+};
 
-GpmClient.prototype.hasMetaKey = function (mod) {
-  return mod & 8 ? true : false
-}
+GpmClient.prototype.hasMetaKey =  function(mod) {
+  return (mod & 8) ? true : false;
+};
 
-module.exports = GpmClient
+module.exports = GpmClient;