@socketsecurity/cli-with-sentry 0.14.137 → 0.14.139

package/dist/blessed/lib/widgets/textarea.js

@@ -0,0 +1,376 @@
+/**
+ * textarea.js - textarea element for blessed
+ * Copyright (c) 2013-2015, Christopher Jeffrey and contributors (MIT License).
+ * https://github.com/chjj/blessed
+ */
+
+/**
+ * Modules
+ */
+
+const unicode = require('../unicode')
+
+const nextTick = global.setImmediate || process.nextTick.bind(process)
+
+const Node = require('./node')
+const Input = require('./input')
+
+/**
+ * Textarea
+ */
+
+function Textarea(options) {
+  const self = this
+
+  if (!(this instanceof Node)) {
+    return new Textarea(options)
+  }
+
+  options = options || {}
+
+  options.scrollable = options.scrollable !== false
+
+  Input.call(this, options)
+
+  this.screen._listenKeys(this)
+
+  this.value = options.value || ''
+
+  this.__updateCursor = this._updateCursor.bind(this)
+  this.on('resize', this.__updateCursor)
+  this.on('move', this.__updateCursor)
+
+  if (options.inputOnFocus) {
+    this.on('focus', this.readInput.bind(this, null))
+  }
+
+  if (!options.inputOnFocus && options.keys) {
+    this.on('keypress', function (ch, key) {
+      if (self._reading) {
+        return
+      }
+      if (key.name === 'enter' || (options.vi && key.name === 'i')) {
+        return self.readInput()
+      }
+      if (key.name === 'e') {
+        return self.readEditor()
+      }
+    })
+  }
+
+  if (options.mouse) {
+    this.on('click', function (data) {
+      if (self._reading) {
+        return
+      }
+      if (data.button !== 'right') {
+        return
+      }
+      self.readEditor()
+    })
+  }
+}
+
+Object.setPrototypeOf(Textarea.prototype, Input.prototype)
+
+Textarea.prototype.type = 'textarea'
+
+Textarea.prototype._updateCursor = function (get) {
+  if (this.screen.focused !== this) {
+    return
+  }
+
+  const lpos = get ? this.lpos : this._getCoords()
+  if (!lpos) {
+    return
+  }
+
+  let last = this._clines[this._clines.length - 1],
+    program = this.screen.program,
+    line,
+    cx,
+    cy
+
+  // Stop a situation where the textarea begins scrolling
+  // and the last cline appears to always be empty from the
+  // _typeScroll `+ '\n'` thing.
+  // Maybe not necessary anymore?
+  if (last === '' && this.value[this.value.length - 1] !== '\n') {
+    last = this._clines[this._clines.length - 2] || ''
+  }
+
+  line = Math.min(
+    this._clines.length - 1 - (this.childBase || 0),
+    lpos.yl - lpos.yi - this.iheight - 1
+  )
+
+  // When calling clearValue() on a full textarea with a border, the first
+  // argument in the above Math.min call ends up being -2. Make sure we stay
+  // positive.
+  line = Math.max(0, line)
+
+  cy = lpos.yi + this.itop + line
+  cx = lpos.xi + this.ileft + this.strWidth(last)
+
+  // XXX Not sure, but this may still sometimes
+  // cause problems when leaving editor.
+  if (cy === program.y && cx === program.x) {
+    return
+  }
+
+  if (cy === program.y) {
+    if (cx > program.x) {
+      program.cuf(cx - program.x)
+    } else if (cx < program.x) {
+      program.cub(program.x - cx)
+    }
+  } else if (cx === program.x) {
+    if (cy > program.y) {
+      program.cud(cy - program.y)
+    } else if (cy < program.y) {
+      program.cuu(program.y - cy)
+    }
+  } else {
+    program.cup(cy, cx)
+  }
+}
+
+Textarea.prototype.input =
+  Textarea.prototype.setInput =
+  Textarea.prototype.readInput =
+    function (callback) {
+      const self = this,
+        focused = this.screen.focused === this
+
+      if (this._reading) {
+        return
+      }
+      this._reading = true
+
+      this._callback = callback
+
+      if (!focused) {
+        this.screen.saveFocus()
+        this.focus()
+      }
+
+      this.screen.grabKeys = true
+
+      this._updateCursor()
+      this.screen.program.showCursor()
+      //this.screen.program.sgr('normal');
+
+      this._done = function fn(err, value) {
+        if (!self._reading) {
+          return
+        }
+
+        if (fn.done) {
+          return
+        }
+        fn.done = true
+
+        self._reading = false
+
+        delete self._callback
+        delete self._done
+
+        self.removeListener('keypress', self.__listener)
+        delete self.__listener
+
+        self.removeListener('blur', self.__done)
+        delete self.__done
+
+        self.screen.program.hideCursor()
+        self.screen.grabKeys = false
+
+        if (!focused) {
+          self.screen.restoreFocus()
+        }
+
+        if (self.options.inputOnFocus) {
+          self.screen.rewindFocus()
+        }
+
+        // Ugly
+        if (err === 'stop') {
+          return
+        }
+
+        if (err) {
+          self.emit('error', err)
+        } else if (value != null) {
+          self.emit('submit', value)
+        } else {
+          self.emit('cancel', value)
+        }
+        self.emit('action', value)
+
+        if (!callback) {
+          return
+        }
+
+        return err ? callback(err) : callback(null, value)
+      }
+
+      // Put this in a nextTick so the current
+      // key event doesn't trigger any keys input.
+      nextTick(function () {
+        self.__listener = self._listener.bind(self)
+        self.on('keypress', self.__listener)
+      })
+
+      this.__done = this._done.bind(this, null, null)
+      this.on('blur', this.__done)
+    }
+
+Textarea.prototype._listener = function (ch, key) {
+  const done = this._done,
+    value = this.value
+
+  if (key.name === 'return') {
+    return
+  }
+  if (key.name === 'enter') {
+    ch = '\n'
+  }
+
+  // TODO: Handle directional keys.
+  if (
+    key.name === 'left' ||
+    key.name === 'right' ||
+    key.name === 'up' ||
+    key.name === 'down'
+  ) {
+  }
+
+  if (this.options.keys && key.ctrl && key.name === 'e') {
+    return this.readEditor()
+  }
+
+  // TODO: Optimize typing by writing directly
+  // to the screen and screen buffer here.
+  if (key.name === 'escape') {
+    done(null, null)
+  } else if (key.name === 'backspace') {
+    if (this.value.length) {
+      if (this.screen.fullUnicode) {
+        if (unicode.isSurrogate(this.value, this.value.length - 2)) {
+          // || unicode.isCombining(this.value, this.value.length - 1)) {
+          this.value = this.value.slice(0, -2)
+        } else {
+          this.value = this.value.slice(0, -1)
+        }
+      } else {
+        this.value = this.value.slice(0, -1)
+      }
+    }
+  } else if (ch) {
+    if (!/^[\x00-\x08\x0b-\x0c\x0e-\x1f\x7f]$/.test(ch)) {
+      this.value += ch
+    }
+  }
+
+  if (this.value !== value) {
+    this.screen.render()
+  }
+}
+
+Textarea.prototype._typeScroll = function () {
+  // XXX Workaround
+  const height = this.height - this.iheight
+  if (this._clines.length - this.childBase > height) {
+    this.scroll(this._clines.length)
+  }
+}
+
+Textarea.prototype.getValue = function () {
+  return this.value
+}
+
+Textarea.prototype.setValue = function (value) {
+  if (value == null) {
+    value = this.value
+  }
+  if (this._value !== value) {
+    this.value = value
+    this._value = value
+    this.setContent(this.value)
+    this._typeScroll()
+    this._updateCursor()
+  }
+}
+
+Textarea.prototype.clearInput = Textarea.prototype.clearValue = function () {
+  return this.setValue('')
+}
+
+Textarea.prototype.submit = function () {
+  if (!this.__listener) {
+    return
+  }
+  return this.__listener('\x1b', { name: 'escape' })
+}
+
+Textarea.prototype.cancel = function () {
+  if (!this.__listener) {
+    return
+  }
+  return this.__listener('\x1b', { name: 'escape' })
+}
+
+Textarea.prototype.render = function () {
+  this.setValue()
+  return this._render()
+}
+
+Textarea.prototype.editor =
+  Textarea.prototype.setEditor =
+  Textarea.prototype.readEditor =
+    function (callback) {
+      const self = this
+
+      if (this._reading) {
+        const _cb = this._callback,
+          cb = callback
+
+        this._done('stop')
+
+        callback = function (err, value) {
+          if (_cb) {
+            _cb(err, value)
+          }
+          if (cb) {
+            cb(err, value)
+          }
+        }
+      }
+
+      if (!callback) {
+        callback = function () {}
+      }
+
+      return this.screen.readEditor(
+        { value: this.value },
+        function (err, value) {
+          if (err) {
+            if (err.message === 'Unsuccessful.') {
+              self.screen.render()
+              return self.readInput(callback)
+            }
+            self.screen.render()
+            self.readInput(callback)
+            return callback(err)
+          }
+          self.setValue(value)
+          self.screen.render()
+          return self.readInput(callback)
+        }
+      )
+    }
+
+/**
+ * Expose
+ */
+
+module.exports = Textarea

package/dist/blessed/lib/widgets/textbox.js

@@ -0,0 +1,79 @@
+/**
+ * textbox.js - textbox element for blessed
+ * Copyright (c) 2013-2015, Christopher Jeffrey and contributors (MIT License).
+ * https://github.com/chjj/blessed
+ */
+
+/**
+ * Modules
+ */
+
+const Node = require('./node')
+const Textarea = require('./textarea')
+
+/**
+ * Textbox
+ */
+
+function Textbox(options) {
+  if (!(this instanceof Node)) {
+    return new Textbox(options)
+  }
+
+  options = options || {}
+
+  options.scrollable = false
+
+  Textarea.call(this, options)
+
+  this.secret = options.secret
+  this.censor = options.censor
+}
+
+Object.setPrototypeOf(Textbox.prototype, Textarea.prototype)
+
+Textbox.prototype.type = 'textbox'
+
+Textbox.prototype.__olistener = Textbox.prototype._listener
+Textbox.prototype._listener = function (ch, key) {
+  if (key.name === 'enter') {
+    this._done(null, this.value)
+    return
+  }
+  return this.__olistener(ch, key)
+}
+
+Textbox.prototype.setValue = function (value) {
+  let visible, val
+  if (value == null) {
+    value = this.value
+  }
+  if (this._value !== value) {
+    value = value.replace(/\n/g, '')
+    this.value = value
+    this._value = value
+    if (this.secret) {
+      this.setContent('')
+    } else if (this.censor) {
+      this.setContent(Array(this.value.length + 1).join('*'))
+    } else {
+      visible = -(this.width - this.iwidth - 1)
+      val = this.value.replace(/\t/g, this.screen.tabc)
+      this.setContent(val.slice(visible))
+    }
+    this._updateCursor()
+  }
+}
+
+Textbox.prototype.submit = function () {
+  if (!this.__listener) {
+    return
+  }
+  return this.__listener('\r', { name: 'enter' })
+}
+
+/**
+ * Expose
+ */
+
+module.exports = Textbox

package/dist/blessed/lib/widgets/video.js

@@ -0,0 +1,130 @@
+/**
+ * video.js - video element for blessed
+ * Copyright (c) 2013-2015, Christopher Jeffrey and contributors (MIT License).
+ * https://github.com/chjj/blessed
+ */
+
+/**
+ * Modules
+ */
+
+const cp = require('node:child_process')
+
+const Node = require('./node')
+const Box = require('./box')
+const Terminal = require('./terminal')
+
+/**
+ * Video
+ */
+
+function Video(options) {
+  let self = this,
+    shell,
+    args
+
+  if (!(this instanceof Node)) {
+    return new Video(options)
+  }
+
+  options = options || {}
+
+  Box.call(this, options)
+
+  if (this.exists('mplayer')) {
+    shell = 'mplayer'
+    args = ['-vo', 'caca', '-quiet', options.file]
+  } else if (this.exists('mpv')) {
+    shell = 'mpv'
+    args = ['--vo', 'caca', '--really-quiet', options.file]
+  } else {
+    this.parseTags = true
+    this.setContent(
+      '{red-fg}{bold}Error:{/bold}' + ' mplayer or mpv not installed.{/red-fg}'
+    )
+    return this
+  }
+
+  const opts = {
+    parent: this,
+    left: 0,
+    top: 0,
+    width: this.width - this.iwidth,
+    height: this.height - this.iheight,
+    shell: shell,
+    args: args.slice()
+  }
+
+  this.now = (Date.now() / 1000) | 0
+  this.start = opts.start || 0
+  if (this.start) {
+    if (shell === 'mplayer') {
+      opts.args.unshift('-ss', this.start + '')
+    } else if (shell === 'mpv') {
+      opts.args.unshift('--start', this.start + '')
+    }
+  }
+
+  const DISPLAY = process.env.DISPLAY
+  delete process.env.DISPLAY
+  this.tty = new Terminal(opts)
+  process.env.DISPLAY = DISPLAY
+
+  this.on('click', function () {
+    self.tty.pty.write('p')
+  })
+
+  // mplayer/mpv cannot resize itself in the terminal, so we have
+  // to restart it at the correct start time.
+  this.on('resize', function () {
+    self.tty.destroy()
+
+    const opts = {
+      parent: self,
+      left: 0,
+      top: 0,
+      width: self.width - self.iwidth,
+      height: self.height - self.iheight,
+      shell: shell,
+      args: args.slice()
+    }
+
+    const watched = ((Date.now() / 1000) | 0) - self.now
+    self.now = (Date.now() / 1000) | 0
+    self.start += watched
+    if (shell === 'mplayer') {
+      opts.args.unshift('-ss', self.start + '')
+    } else if (shell === 'mpv') {
+      opts.args.unshift('--start', self.start + '')
+    }
+
+    const DISPLAY = process.env.DISPLAY
+    delete process.env.DISPLAY
+    self.tty = new Terminal(opts)
+    process.env.DISPLAY = DISPLAY
+    self.screen.render()
+  })
+}
+
+Object.setPrototypeOf(Video.prototype, Box.prototype)
+
+Video.prototype.type = 'video'
+
+Video.prototype.exists = function (program) {
+  try {
+    return !!+cp
+      .execSync(
+        'type ' + program + ' > /dev/null 2> /dev/null' + ' && echo 1',
+        { encoding: 'utf8' }
+      )
+      .trim()
+  } catch (e) {
+    return false
+  }
+}
+
+/**
+ * Expose
+ */
+
+module.exports = Video

package/dist/blessed/usr/fonts/AUTHORS

@@ -0,0 +1 @@
+Dimitar Zhekov <dimitar.zhekov@gmail.com>

package/dist/blessed/usr/fonts/LICENSE

@@ -0,0 +1,94 @@
+Copyright (c) 2014 Dimitar Toshkov Zhekov,
+with Reserved Font Name "Terminus Font".
+
+This Font Software is licensed under the SIL Open Font License, Version 1.1.
+This license is copied below, and is also available with a FAQ at:
+http://scripts.sil.org/OFL
+
+
+-----------------------------------------------------------
+SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
+-----------------------------------------------------------
+
+PREAMBLE
+The goals of the Open Font License (OFL) are to stimulate worldwide
+development of collaborative font projects, to support the font creation
+efforts of academic and linguistic communities, and to provide a free and
+open framework in which fonts may be shared and improved in partnership
+with others.
+
+The OFL allows the licensed fonts to be used, studied, modified and
+redistributed freely as long as they are not sold by themselves. The
+fonts, including any derivative works, can be bundled, embedded, 
+redistributed and/or sold with any software provided that any reserved
+names are not used by derivative works. The fonts and derivatives,
+however, cannot be released under any other type of license. The
+requirement for fonts to remain under this license does not apply
+to any document created using the fonts or their derivatives.
+
+DEFINITIONS
+"Font Software" refers to the set of files released by the Copyright
+Holder(s) under this license and clearly marked as such. This may
+include source files, build scripts and documentation.
+
+"Reserved Font Name" refers to any names specified as such after the
+copyright statement(s).
+
+"Original Version" refers to the collection of Font Software components as
+distributed by the Copyright Holder(s).
+
+"Modified Version" refers to any derivative made by adding to, deleting,
+or substituting -- in part or in whole -- any of the components of the
+Original Version, by changing formats or by porting the Font Software to a
+new environment.
+
+"Author" refers to any designer, engineer, programmer, technical
+writer or other person who contributed to the Font Software.
+
+PERMISSION & CONDITIONS
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of the Font Software, to use, study, copy, merge, embed, modify,
+redistribute, and sell modified and unmodified copies of the Font
+Software, subject to the following conditions:
+
+1) Neither the Font Software nor any of its individual components,
+in Original or Modified Versions, may be sold by itself.
+
+2) Original or Modified Versions of the Font Software may be bundled,
+redistributed and/or sold with any software, provided that each copy
+contains the above copyright notice and this license. These can be
+included either as stand-alone text files, human-readable headers or
+in the appropriate machine-readable metadata fields within text or
+binary files as long as those fields can be easily viewed by the user.
+
+3) No Modified Version of the Font Software may use the Reserved Font
+Name(s) unless explicit written permission is granted by the corresponding
+Copyright Holder. This restriction only applies to the primary font name as
+presented to the users.
+
+4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
+Software shall not be used to promote, endorse or advertise any
+Modified Version, except to acknowledge the contribution(s) of the
+Copyright Holder(s) and the Author(s) or with their explicit written
+permission.
+
+5) The Font Software, modified or unmodified, in part or in whole,
+must be distributed entirely under this license, and must not be
+distributed under any other license. The requirement for fonts to
+remain under this license does not apply to any document created
+using the Font Software.
+
+TERMINATION
+This license becomes null and void if any of the above conditions are
+not met.
+
+DISCLAIMER
+THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
+OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
+COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
+DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
+OTHER DEALINGS IN THE FONT SOFTWARE.