@socketsecurity/cli-with-sentry 0.15.10 → 0.15.12

package/external/blessed/lib/widgets/message.js

@@ -10,8 +10,8 @@
  * Modules
  */
 
-const Node = require('./node')
-const Box = require('./box')
+var Node = require('./node');
+var Box = require('./box');
 
 /**
  * Message / Error
@@ -19,34 +19,29 @@ const Box = require('./box')
 
 function Message(options) {
   if (!(this instanceof Node)) {
-    return new Message(options)
+    return new Message(options);
   }
 
-  options = options || {}
-  options.tags = true
+  options = options || {};
+  options.tags = true;
 
-  Box.call(this, options)
+  Box.call(this, options);
 }
 
-Object.setPrototypeOf(Message.prototype, Box.prototype)
+Object.setPrototypeOf(Message.prototype, Box.prototype);
 
-Message.prototype.type = 'message'
+Message.prototype.type = 'message';
 
-Message.prototype.log = Message.prototype.display = function (
-  text,
-  time,
-  callback
-) {
-  const self = this
+Message.prototype.log =
+Message.prototype.display = function(text, time, callback) {
+  var self = this;
 
   if (typeof time === 'function') {
-    callback = time
-    time = null
+    callback = time;
+    time = null;
   }
 
-  if (time == null) {
-    time = 3
-  }
+  if (time == null) time = 3;
 
   // Keep above:
   // var parent = this.parent;
@@ -54,94 +49,77 @@ Message.prototype.log = Message.prototype.display = function (
   // parent.append(this);
 
   if (this.scrollable) {
-    this.screen.saveFocus()
-    this.focus()
-    this.scrollTo(0)
+    this.screen.saveFocus();
+    this.focus();
+    this.scrollTo(0);
   }
 
-  this.show()
-  this.setContent(text)
-  this.screen.render()
+  this.show();
+  this.setContent(text);
+  this.screen.render();
 
   if (time === Infinity || time === -1 || time === 0) {
-    const end = function () {
-      if (end.done) {
-        return
-      }
-      end.done = true
+    var end = function() {
+      if (end.done) return;
+      end.done = true;
       if (self.scrollable) {
         try {
-          self.screen.restoreFocus()
-        } catch (e) {}
-      }
-      self.hide()
-      self.screen.render()
-      if (callback) {
-        callback()
+          self.screen.restoreFocus();
+        } catch (e) {
+          ;
+        }
       }
-    }
+      self.hide();
+      self.screen.render();
+      if (callback) callback();
+    };
 
-    setTimeout(function () {
+    setTimeout(function() {
       self.onScreenEvent('keypress', function fn(ch, key) {
-        if (key.name === 'mouse') {
-          return
-        }
+        if (key.name === 'mouse') return;
         if (self.scrollable) {
-          if (
-            key.name === 'up' ||
-            (self.options.vi && key.name === 'k') ||
-            key.name === 'down' ||
-            (self.options.vi && key.name === 'j') ||
-            (self.options.vi && key.name === 'u' && key.ctrl) ||
-            (self.options.vi && key.name === 'd' && key.ctrl) ||
-            (self.options.vi && key.name === 'b' && key.ctrl) ||
-            (self.options.vi && key.name === 'f' && key.ctrl) ||
-            (self.options.vi && key.name === 'g' && !key.shift) ||
-            (self.options.vi && key.name === 'g' && key.shift)
-          ) {
-            return
+          if ((key.name === 'up' || (self.options.vi && key.name === 'k'))
+            || (key.name === 'down' || (self.options.vi && key.name === 'j'))
+            || (self.options.vi && key.name === 'u' && key.ctrl)
+            || (self.options.vi && key.name === 'd' && key.ctrl)
+            || (self.options.vi && key.name === 'b' && key.ctrl)
+            || (self.options.vi && key.name === 'f' && key.ctrl)
+            || (self.options.vi && key.name === 'g' && !key.shift)
+            || (self.options.vi && key.name === 'g' && key.shift)) {
+            return;
           }
         }
-        if (
-          self.options.ignoreKeys &&
-          ~self.options.ignoreKeys.indexOf(key.name)
-        ) {
-          return
+        if (self.options.ignoreKeys && ~self.options.ignoreKeys.indexOf(key.name)) {
+          return;
         }
-        self.removeScreenEvent('keypress', fn)
-        end()
-      })
+        self.removeScreenEvent('keypress', fn);
+        end();
+      });
       // XXX May be affected by new element.options.mouse option.
-      if (!self.options.mouse) {
-        return
-      }
+      if (!self.options.mouse) return;
       self.onScreenEvent('mouse', function fn(data) {
-        if (data.action === 'mousemove') {
-          return
-        }
-        self.removeScreenEvent('mouse', fn)
-        end()
-      })
-    }, 10)
+        if (data.action === 'mousemove') return;
+        self.removeScreenEvent('mouse', fn);
+        end();
+      });
+    }, 10);
 
-    return
+    return;
   }
 
-  setTimeout(function () {
-    self.hide()
-    self.screen.render()
-    if (callback) {
-      callback()
-    }
-  }, time * 1000)
-}
+  setTimeout(function() {
+    self.hide();
+    self.screen.render();
+    if (callback) callback();
+  }, time * 1000);
+};
 
-Message.prototype.error = function (text, time, callback) {
-  return this.display('{red-fg}Error: ' + text + '{/red-fg}', time, callback)
-}
+Message.prototype.error = function(text, time, callback) {
+  return this.display('{red-fg}Error: ' + text + '{/red-fg}', time, callback);
+};
 
 /**
  * Expose
  */
 
-module.exports = Message
+module.exports = Message;

package/external/blessed/lib/widgets/node.js

@@ -10,306 +10,274 @@
  * Modules
  */
 
-const EventEmitter = require('../events').EventEmitter
+var EventEmitter = require('../events').EventEmitter;
 
 /**
  * Node
  */
 
 function Node(options) {
-  const self = this
+  var self = this;
   if (!(this instanceof Node)) {
-    return new Node(options)
+    return new Node(options);
   }
 
-  EventEmitter.call(this)
+  EventEmitter.call(this);
 
-  options = options || {}
-  this.options = options
+  options = options || {};
+  this.options = options;
 
-  this.screen = this.screen || options.screen
+  this.screen = this.screen || options.screen;
 
   if (!this.screen) {
-    const Screen = require('./screen')
+    var Screen = require('./screen');
     if (this.type === 'screen') {
-      this.screen = this
+      this.screen = this;
     } else if (Screen.total === 1) {
-      this.screen = Screen.global
+      this.screen = Screen.global;
     } else if (options.parent) {
-      this.screen = options.parent
+      this.screen = options.parent;
       while (this.screen && this.screen.type !== 'screen') {
-        this.screen = this.screen.parent
+        this.screen = this.screen.parent;
       }
     } else if (Screen.total) {
       // This _should_ work in most cases as long as the element is appended
       // synchronously after the screen's creation. Throw error if not.
-      this.screen = Screen.instances[Screen.instances.length - 1]
-      process.nextTick(function () {
+      this.screen = Screen.instances[Screen.instances.length - 1];
+      process.nextTick(function() {
         if (!self.parent) {
-          throw new Error(
-            'Element (' +
-              self.type +
-              ')' +
-              ' was not appended synchronously after the' +
-              " screen's creation. Please set a `parent`" +
-              " or `screen` option in the element's constructor" +
-              ' if you are going to use multiple screens and' +
-              ' append the element later.'
-          )
+          throw new Error('Element (' + self.type + ')'
+            + ' was not appended synchronously after the'
+            + ' screen\'s creation. Please set a `parent`'
+            + ' or `screen` option in the element\'s constructor'
+            + ' if you are going to use multiple screens and'
+            + ' append the element later.');
         }
-      })
+      });
     } else {
-      throw new Error('No active screen.')
+      throw new Error('No active screen.');
     }
   }
 
-  this.parent = options.parent || null
-  this.children = []
-  this.$ = this._ = this.data = {}
-  this.uid = Node.uid++
-  this.index = this.index != null ? this.index : -1
+  this.parent = options.parent || null;
+  this.children = [];
+  this.$ = this._ = this.data = {};
+  this.uid = Node.uid++;
+  this.index = this.index != null ? this.index : -1;
 
   if (this.type !== 'screen') {
-    this.detached = true
+    this.detached = true;
   }
 
   if (this.parent) {
-    this.parent.append(this)
+    this.parent.append(this);
   }
 
-  ;(options.children || []).forEach(this.append.bind(this))
+  (options.children || []).forEach(this.append.bind(this));
 }
 
-Node.uid = 0
+Node.uid = 0;
 
-Object.setPrototypeOf(Node.prototype, EventEmitter.prototype)
+Object.setPrototypeOf(Node.prototype, EventEmitter.prototype);
 
-Node.prototype.type = 'node'
+Node.prototype.type = 'node';
 
-Node.prototype.insert = function (element, i) {
-  const self = this
+Node.prototype.insert = function(element, i) {
+  var self = this;
 
   if (element.screen && element.screen !== this.screen) {
-    throw new Error("Cannot switch a node's screen.")
+    throw new Error('Cannot switch a node\'s screen.');
   }
 
-  element.detach()
-  element.parent = this
-  element.screen = this.screen
+  element.detach();
+  element.parent = this;
+  element.screen = this.screen;
 
   if (i === 0) {
-    this.children.unshift(element)
+    this.children.unshift(element);
   } else if (i === this.children.length) {
-    this.children.push(element)
+    this.children.push(element);
   } else {
-    this.children.splice(i, 0, element)
+    this.children.splice(i, 0, element);
   }
 
-  element.emit('reparent', this)
-  this.emit('adopt', element)
+  element.emit('reparent', this);
+  this.emit('adopt', element);
 
-  ;(function emit(el) {
-    const n = el.detached !== self.detached
-    el.detached = self.detached
-    if (n) {
-      el.emit('attach')
-    }
-    el.children.forEach(emit)
-  })(element)
+  (function emit(el) {
+    var n = el.detached !== self.detached;
+    el.detached = self.detached;
+    if (n) el.emit('attach');
+    el.children.forEach(emit);
+  })(element);
 
   if (!this.screen.focused) {
-    this.screen.focused = element
+    this.screen.focused = element;
   }
-}
+};
 
-Node.prototype.prepend = function (element) {
-  this.insert(element, 0)
-}
+Node.prototype.prepend = function(element) {
+  this.insert(element, 0);
+};
 
-Node.prototype.append = function (element) {
-  this.insert(element, this.children.length)
-}
+Node.prototype.append = function(element) {
+  this.insert(element, this.children.length);
+};
 
-Node.prototype.insertBefore = function (element, other) {
-  const i = this.children.indexOf(other)
-  if (~i) {
-    this.insert(element, i)
-  }
-}
+Node.prototype.insertBefore = function(element, other) {
+  var i = this.children.indexOf(other);
+  if (~i) this.insert(element, i);
+};
 
-Node.prototype.insertAfter = function (element, other) {
-  const i = this.children.indexOf(other)
-  if (~i) {
-    this.insert(element, i + 1)
-  }
-}
+Node.prototype.insertAfter = function(element, other) {
+  var i = this.children.indexOf(other);
+  if (~i) this.insert(element, i + 1);
+};
 
-Node.prototype.remove = function (element) {
-  if (element.parent !== this) {
-    return
-  }
+Node.prototype.remove = function(element) {
+  if (element.parent !== this) return;
 
-  let i = this.children.indexOf(element)
-  if (!~i) {
-    return
-  }
+  var i = this.children.indexOf(element);
+  if (!~i) return;
 
-  element.clearPos()
+  element.clearPos();
 
-  element.parent = null
+  element.parent = null;
 
-  this.children.splice(i, 1)
+  this.children.splice(i, 1);
 
-  i = this.screen.clickable.indexOf(element)
-  if (~i) {
-    this.screen.clickable.splice(i, 1)
-  }
-  i = this.screen.keyable.indexOf(element)
-  if (~i) {
-    this.screen.keyable.splice(i, 1)
-  }
+  i = this.screen.clickable.indexOf(element);
+  if (~i) this.screen.clickable.splice(i, 1);
+  i = this.screen.keyable.indexOf(element);
+  if (~i) this.screen.keyable.splice(i, 1);
 
-  element.emit('reparent', null)
-  this.emit('remove', element)
+  element.emit('reparent', null);
+  this.emit('remove', element);
 
-  ;(function emit(el) {
-    const n = el.detached !== true
-    el.detached = true
-    if (n) {
-      el.emit('detach')
-    }
-    el.children.forEach(emit)
-  })(element)
+  (function emit(el) {
+    var n = el.detached !== true;
+    el.detached = true;
+    if (n) el.emit('detach');
+    el.children.forEach(emit);
+  })(element);
 
   if (this.screen.focused === element) {
-    this.screen.rewindFocus()
-  }
-}
-
-Node.prototype.detach = function () {
-  if (this.parent) {
-    this.parent.remove(this)
-  }
-}
-
-Node.prototype.free = function () {
-  return
-}
-
-Node.prototype.destroy = function () {
-  this.detach()
-  this.forDescendants(function (el) {
-    el.free()
-    el.destroyed = true
-    el.emit('destroy')
-  }, this)
-}
-
-Node.prototype.forDescendants = function (iter, s) {
-  if (s) {
-    iter(this)
+    this.screen.rewindFocus();
   }
+};
+
+Node.prototype.detach = function() {
+  if (this.parent) this.parent.remove(this);
+};
+
+Node.prototype.free = function() {
+  return;
+};
+
+Node.prototype.destroy = function() {
+  this.detach();
+  this.forDescendants(function(el) {
+    el.free();
+    el.destroyed = true;
+    el.emit('destroy');
+  }, this);
+};
+
+Node.prototype.forDescendants = function(iter, s) {
+  if (s) iter(this);
   this.children.forEach(function emit(el) {
-    iter(el)
-    el.children.forEach(emit)
-  })
-}
-
-Node.prototype.forAncestors = function (iter, s) {
-  let el = this
-  if (s) {
-    iter(this)
-  }
-  while ((el = el.parent)) {
-    iter(el)
+    iter(el);
+    el.children.forEach(emit);
+  });
+};
+
+Node.prototype.forAncestors = function(iter, s) {
+  var el = this;
+  if (s) iter(this);
+  while (el = el.parent) {
+    iter(el);
   }
-}
-
-Node.prototype.collectDescendants = function (s) {
-  const out = []
-  this.forDescendants(function (el) {
-    out.push(el)
-  }, s)
-  return out
-}
-
-Node.prototype.collectAncestors = function (s) {
-  const out = []
-  this.forAncestors(function (el) {
-    out.push(el)
-  }, s)
-  return out
-}
-
-Node.prototype.emitDescendants = function () {
-  let args = Array.prototype.slice(arguments),
-    iter
+};
+
+Node.prototype.collectDescendants = function(s) {
+  var out = [];
+  this.forDescendants(function(el) {
+    out.push(el);
+  }, s);
+  return out;
+};
+
+Node.prototype.collectAncestors = function(s) {
+  var out = [];
+  this.forAncestors(function(el) {
+    out.push(el);
+  }, s);
+  return out;
+};
+
+Node.prototype.emitDescendants = function() {
+  var args = Array.prototype.slice(arguments)
+    , iter;
 
   if (typeof args[args.length - 1] === 'function') {
-    iter = args.pop()
+    iter = args.pop();
   }
 
-  return this.forDescendants(function (el) {
-    if (iter) {
-      iter(el)
-    }
-    el.emit.apply(el, args)
-  }, true)
-}
+  return this.forDescendants(function(el) {
+    if (iter) iter(el);
+    el.emit.apply(el, args);
+  }, true);
+};
 
-Node.prototype.emitAncestors = function () {
-  let args = Array.prototype.slice(arguments),
-    iter
+Node.prototype.emitAncestors = function() {
+  var args = Array.prototype.slice(arguments)
+    , iter;
 
   if (typeof args[args.length - 1] === 'function') {
-    iter = args.pop()
+    iter = args.pop();
   }
 
-  return this.forAncestors(function (el) {
-    if (iter) {
-      iter(el)
-    }
-    el.emit.apply(el, args)
-  }, true)
-}
+  return this.forAncestors(function(el) {
+    if (iter) iter(el);
+    el.emit.apply(el, args);
+  }, true);
+};
 
-Node.prototype.hasDescendant = function (target) {
+Node.prototype.hasDescendant = function(target) {
   return (function find(el) {
-    for (let i = 0; i < el.children.length; i++) {
+    for (var i = 0; i < el.children.length; i++) {
       if (el.children[i] === target) {
-        return true
+        return true;
       }
       if (find(el.children[i]) === true) {
-        return true
+        return true;
       }
     }
-    return false
-  })(this)
-}
-
-Node.prototype.hasAncestor = function (target) {
-  let el = this
-  while ((el = el.parent)) {
-    if (el === target) {
-      return true
-    }
+    return false;
+  })(this);
+};
+
+Node.prototype.hasAncestor = function(target) {
+  var el = this;
+  while (el = el.parent) {
+    if (el === target) return true;
   }
-  return false
-}
+  return false;
+};
 
-Node.prototype.get = function (name, value) {
+Node.prototype.get = function(name, value) {
   if (this.data.hasOwnProperty(name)) {
-    return this.data[name]
+    return this.data[name];
   }
-  return value
-}
+  return value;
+};
 
-Node.prototype.set = function (name, value) {
-  return (this.data[name] = value)
-}
+Node.prototype.set = function(name, value) {
+  return this.data[name] = value;
+};
 
 /**
  * Expose
  */
 
-module.exports = Node
+module.exports = Node;