jfrog-cli-v2-jf 2.6.0

package/node-v8.11.1-linux-x64/lib/node_modules/npm/node_modules/columnify/node_modules/wcwidth/Readme.md

@@ -0,0 +1,33 @@
+# wcwidth
+
+Determine columns needed for a fixed-size wide-character string
+
+----
+
+wcwidth is a simple JavaScript port of [wcwidth](http://man7.org/linux/man-pages/man3/wcswidth.3.html) implemented in C by Markus Kuhn.
+
+JavaScript port [originally](https://github.com/mycoboco/wcwidth.js) written by Woong Jun <woong.jun@gmail.com> (http://code.woong.org/)
+
+## Example
+
+```js
+'한'.length    // => 1
+wcwidth('한');   // => 2
+
+'한글'.length    // => 2
+wcwidth('한글'); // => 4
+```
+
+`wcwidth()` and its string version, `wcswidth()` are defined by IEEE Std
+1002.1-2001, a.k.a. POSIX.1-2001, and return the number of columns used
+to represent the given wide character and string.
+
+Markus's implementation assumes the wide character given to those
+functions to be encoded in ISO 10646, which is almost true for
+JavaScript's characters.
+
+[Further explaination here](docs)
+
+## License
+
+MIT

package/node-v8.11.1-linux-x64/lib/node_modules/npm/node_modules/columnify/node_modules/wcwidth/combining.js

@@ -0,0 +1,50 @@
+module.exports = [
+    [ 0x0300, 0x036F ], [ 0x0483, 0x0486 ], [ 0x0488, 0x0489 ],
+    [ 0x0591, 0x05BD ], [ 0x05BF, 0x05BF ], [ 0x05C1, 0x05C2 ],
+    [ 0x05C4, 0x05C5 ], [ 0x05C7, 0x05C7 ], [ 0x0600, 0x0603 ],
+    [ 0x0610, 0x0615 ], [ 0x064B, 0x065E ], [ 0x0670, 0x0670 ],
+    [ 0x06D6, 0x06E4 ], [ 0x06E7, 0x06E8 ], [ 0x06EA, 0x06ED ],
+    [ 0x070F, 0x070F ], [ 0x0711, 0x0711 ], [ 0x0730, 0x074A ],
+    [ 0x07A6, 0x07B0 ], [ 0x07EB, 0x07F3 ], [ 0x0901, 0x0902 ],
+    [ 0x093C, 0x093C ], [ 0x0941, 0x0948 ], [ 0x094D, 0x094D ],
+    [ 0x0951, 0x0954 ], [ 0x0962, 0x0963 ], [ 0x0981, 0x0981 ],
+    [ 0x09BC, 0x09BC ], [ 0x09C1, 0x09C4 ], [ 0x09CD, 0x09CD ],
+    [ 0x09E2, 0x09E3 ], [ 0x0A01, 0x0A02 ], [ 0x0A3C, 0x0A3C ],
+    [ 0x0A41, 0x0A42 ], [ 0x0A47, 0x0A48 ], [ 0x0A4B, 0x0A4D ],
+    [ 0x0A70, 0x0A71 ], [ 0x0A81, 0x0A82 ], [ 0x0ABC, 0x0ABC ],
+    [ 0x0AC1, 0x0AC5 ], [ 0x0AC7, 0x0AC8 ], [ 0x0ACD, 0x0ACD ],
+    [ 0x0AE2, 0x0AE3 ], [ 0x0B01, 0x0B01 ], [ 0x0B3C, 0x0B3C ],
+    [ 0x0B3F, 0x0B3F ], [ 0x0B41, 0x0B43 ], [ 0x0B4D, 0x0B4D ],
+    [ 0x0B56, 0x0B56 ], [ 0x0B82, 0x0B82 ], [ 0x0BC0, 0x0BC0 ],
+    [ 0x0BCD, 0x0BCD ], [ 0x0C3E, 0x0C40 ], [ 0x0C46, 0x0C48 ],
+    [ 0x0C4A, 0x0C4D ], [ 0x0C55, 0x0C56 ], [ 0x0CBC, 0x0CBC ],
+    [ 0x0CBF, 0x0CBF ], [ 0x0CC6, 0x0CC6 ], [ 0x0CCC, 0x0CCD ],
+    [ 0x0CE2, 0x0CE3 ], [ 0x0D41, 0x0D43 ], [ 0x0D4D, 0x0D4D ],
+    [ 0x0DCA, 0x0DCA ], [ 0x0DD2, 0x0DD4 ], [ 0x0DD6, 0x0DD6 ],
+    [ 0x0E31, 0x0E31 ], [ 0x0E34, 0x0E3A ], [ 0x0E47, 0x0E4E ],
+    [ 0x0EB1, 0x0EB1 ], [ 0x0EB4, 0x0EB9 ], [ 0x0EBB, 0x0EBC ],
+    [ 0x0EC8, 0x0ECD ], [ 0x0F18, 0x0F19 ], [ 0x0F35, 0x0F35 ],
+    [ 0x0F37, 0x0F37 ], [ 0x0F39, 0x0F39 ], [ 0x0F71, 0x0F7E ],
+    [ 0x0F80, 0x0F84 ], [ 0x0F86, 0x0F87 ], [ 0x0F90, 0x0F97 ],
+    [ 0x0F99, 0x0FBC ], [ 0x0FC6, 0x0FC6 ], [ 0x102D, 0x1030 ],
+    [ 0x1032, 0x1032 ], [ 0x1036, 0x1037 ], [ 0x1039, 0x1039 ],
+    [ 0x1058, 0x1059 ], [ 0x1160, 0x11FF ], [ 0x135F, 0x135F ],
+    [ 0x1712, 0x1714 ], [ 0x1732, 0x1734 ], [ 0x1752, 0x1753 ],
+    [ 0x1772, 0x1773 ], [ 0x17B4, 0x17B5 ], [ 0x17B7, 0x17BD ],
+    [ 0x17C6, 0x17C6 ], [ 0x17C9, 0x17D3 ], [ 0x17DD, 0x17DD ],
+    [ 0x180B, 0x180D ], [ 0x18A9, 0x18A9 ], [ 0x1920, 0x1922 ],
+    [ 0x1927, 0x1928 ], [ 0x1932, 0x1932 ], [ 0x1939, 0x193B ],
+    [ 0x1A17, 0x1A18 ], [ 0x1B00, 0x1B03 ], [ 0x1B34, 0x1B34 ],
+    [ 0x1B36, 0x1B3A ], [ 0x1B3C, 0x1B3C ], [ 0x1B42, 0x1B42 ],
+    [ 0x1B6B, 0x1B73 ], [ 0x1DC0, 0x1DCA ], [ 0x1DFE, 0x1DFF ],
+    [ 0x200B, 0x200F ], [ 0x202A, 0x202E ], [ 0x2060, 0x2063 ],
+    [ 0x206A, 0x206F ], [ 0x20D0, 0x20EF ], [ 0x302A, 0x302F ],
+    [ 0x3099, 0x309A ], [ 0xA806, 0xA806 ], [ 0xA80B, 0xA80B ],
+    [ 0xA825, 0xA826 ], [ 0xFB1E, 0xFB1E ], [ 0xFE00, 0xFE0F ],
+    [ 0xFE20, 0xFE23 ], [ 0xFEFF, 0xFEFF ], [ 0xFFF9, 0xFFFB ],
+    [ 0x10A01, 0x10A03 ], [ 0x10A05, 0x10A06 ], [ 0x10A0C, 0x10A0F ],
+    [ 0x10A38, 0x10A3A ], [ 0x10A3F, 0x10A3F ], [ 0x1D167, 0x1D169 ],
+    [ 0x1D173, 0x1D182 ], [ 0x1D185, 0x1D18B ], [ 0x1D1AA, 0x1D1AD ],
+    [ 0x1D242, 0x1D244 ], [ 0xE0001, 0xE0001 ], [ 0xE0020, 0xE007F ],
+    [ 0xE0100, 0xE01EF ]
+]

package/node-v8.11.1-linux-x64/lib/node_modules/npm/node_modules/columnify/node_modules/wcwidth/docs/index.md

@@ -0,0 +1,65 @@
+### Javascript porting of Markus Kuhn's wcwidth() implementation
+
+The following explanation comes from the original C implementation:
+
+This is an implementation of wcwidth() and wcswidth() (defined in
+IEEE Std 1002.1-2001) for Unicode.
+
+http://www.opengroup.org/onlinepubs/007904975/functions/wcwidth.html
+http://www.opengroup.org/onlinepubs/007904975/functions/wcswidth.html
+
+In fixed-width output devices, Latin characters all occupy a single
+"cell" position of equal width, whereas ideographic CJK characters
+occupy two such cells. Interoperability between terminal-line
+applications and (teletype-style) character terminals using the
+UTF-8 encoding requires agreement on which character should advance
+the cursor by how many cell positions. No established formal
+standards exist at present on which Unicode character shall occupy
+how many cell positions on character terminals. These routines are
+a first attempt of defining such behavior based on simple rules
+applied to data provided by the Unicode Consortium.
+
+For some graphical characters, the Unicode standard explicitly
+defines a character-cell width via the definition of the East Asian
+FullWidth (F), Wide (W), Half-width (H), and Narrow (Na) classes.
+In all these cases, there is no ambiguity about which width a
+terminal shall use. For characters in the East Asian Ambiguous (A)
+class, the width choice depends purely on a preference of backward
+compatibility with either historic CJK or Western practice.
+Choosing single-width for these characters is easy to justify as
+the appropriate long-term solution, as the CJK practice of
+displaying these characters as double-width comes from historic
+implementation simplicity (8-bit encoded characters were displayed
+single-width and 16-bit ones double-width, even for Greek,
+Cyrillic, etc.) and not any typographic considerations.
+
+Much less clear is the choice of width for the Not East Asian
+(Neutral) class. Existing practice does not dictate a width for any
+of these characters. It would nevertheless make sense
+typographically to allocate two character cells to characters such
+as for instance EM SPACE or VOLUME INTEGRAL, which cannot be
+represented adequately with a single-width glyph. The following
+routines at present merely assign a single-cell width to all
+neutral characters, in the interest of simplicity. This is not
+entirely satisfactory and should be reconsidered before
+establishing a formal standard in this area. At the moment, the
+decision which Not East Asian (Neutral) characters should be
+represented by double-width glyphs cannot yet be answered by
+applying a simple rule from the Unicode database content. Setting
+up a proper standard for the behavior of UTF-8 character terminals
+will require a careful analysis not only of each Unicode character,
+but also of each presentation form, something the author of these
+routines has avoided to do so far.
+
+http://www.unicode.org/unicode/reports/tr11/
+
+Markus Kuhn -- 2007-05-26 (Unicode 5.0)
+
+Permission to use, copy, modify, and distribute this software
+for any purpose and without fee is hereby granted. The author
+disclaims all warranties with regard to this software.
+
+Latest version: http://www.cl.cam.ac.uk/~mgk25/ucs/wcwidth.c
+
+
+

package/node-v8.11.1-linux-x64/lib/node_modules/npm/node_modules/columnify/node_modules/wcwidth/index.js

@@ -0,0 +1,99 @@
+"use strict"
+
+var defaults = require('defaults')
+var combining = require('./combining')
+
+var DEFAULTS = {
+  nul: 0,
+  control: 0
+}
+
+module.exports = function wcwidth(str) {
+  return wcswidth(str, DEFAULTS)
+}
+
+module.exports.config = function(opts) {
+  opts = defaults(opts || {}, DEFAULTS)
+  return function wcwidth(str) {
+    return wcswidth(str, opts)
+  }
+}
+
+/*
+ *  The following functions define the column width of an ISO 10646
+ *  character as follows:
+ *  - The null character (U+0000) has a column width of 0.
+ *  - Other C0/C1 control characters and DEL will lead to a return value
+ *    of -1.
+ *  - Non-spacing and enclosing combining characters (general category
+ *    code Mn or Me in the
+ *    Unicode database) have a column width of 0.
+ *  - SOFT HYPHEN (U+00AD) has a column width of 1.
+ *  - Other format characters (general category code Cf in the Unicode
+ *    database) and ZERO WIDTH
+ *    SPACE (U+200B) have a column width of 0.
+ *  - Hangul Jamo medial vowels and final consonants (U+1160-U+11FF)
+ *    have a column width of 0.
+ *  - Spacing characters in the East Asian Wide (W) or East Asian
+ *    Full-width (F) category as
+ *    defined in Unicode Technical Report #11 have a column width of 2.
+ *  - All remaining characters (including all printable ISO 8859-1 and
+ *    WGL4 characters, Unicode control characters, etc.) have a column
+ *    width of 1.
+ *  This implementation assumes that characters are encoded in ISO 10646.
+*/
+
+function wcswidth(str, opts) {
+  if (typeof str !== 'string') return wcwidth(str, opts)
+
+  var s = 0
+  for (var i = 0; i < str.length; i++) {
+    var n = wcwidth(str.charCodeAt(i), opts)
+    if (n < 0) return -1
+    s += n
+  }
+
+  return s
+}
+
+function wcwidth(ucs, opts) {
+  // test for 8-bit control characters
+  if (ucs === 0) return opts.nul
+  if (ucs < 32 || (ucs >= 0x7f && ucs < 0xa0)) return opts.control
+
+  // binary search in table of non-spacing characters
+  if (bisearch(ucs)) return 0
+
+  // if we arrive here, ucs is not a combining or C0/C1 control character
+  return 1 +
+      (ucs >= 0x1100 &&
+       (ucs <= 0x115f ||                       // Hangul Jamo init. consonants
+        ucs == 0x2329 || ucs == 0x232a ||
+        (ucs >= 0x2e80 && ucs <= 0xa4cf &&
+         ucs != 0x303f) ||                     // CJK ... Yi
+        (ucs >= 0xac00 && ucs <= 0xd7a3) ||    // Hangul Syllables
+        (ucs >= 0xf900 && ucs <= 0xfaff) ||    // CJK Compatibility Ideographs
+        (ucs >= 0xfe10 && ucs <= 0xfe19) ||    // Vertical forms
+        (ucs >= 0xfe30 && ucs <= 0xfe6f) ||    // CJK Compatibility Forms
+        (ucs >= 0xff00 && ucs <= 0xff60) ||    // Fullwidth Forms
+        (ucs >= 0xffe0 && ucs <= 0xffe6) ||
+        (ucs >= 0x20000 && ucs <= 0x2fffd) ||
+        (ucs >= 0x30000 && ucs <= 0x3fffd)));
+}
+
+function bisearch(ucs) {
+  var min = 0
+  var max = combining.length - 1
+  var mid
+
+  if (ucs < combining[0][0] || ucs > combining[max][1]) return false
+
+  while (max >= min) {
+    mid = Math.floor((min + max) / 2)
+    if (ucs > combining[mid][1]) min = mid + 1
+    else if (ucs < combining[mid][0]) max = mid - 1
+    else return true
+  }
+
+  return false
+}

package/node-v8.11.1-linux-x64/lib/node_modules/npm/node_modules/columnify/node_modules/wcwidth/package.json

@@ -0,0 +1,76 @@
+{
+  "_from": "wcwidth@^1.0.0",
+  "_id": "wcwidth@1.0.1",
+  "_integrity": "sha1-8LDc+RW8X/FSivrbLA4XtTLaL+g=",
+  "_location": "/columnify/wcwidth",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "range",
+    "registry": true,
+    "raw": "wcwidth@^1.0.0",
+    "name": "wcwidth",
+    "escapedName": "wcwidth",
+    "rawSpec": "^1.0.0",
+    "saveSpec": null,
+    "fetchSpec": "^1.0.0"
+  },
+  "_requiredBy": [
+    "/columnify"
+  ],
+  "_resolved": "https://registry.npmjs.org/wcwidth/-/wcwidth-1.0.1.tgz",
+  "_shasum": "f0b0dcf915bc5ff1528afadb2c0e17b532da2fe8",
+  "_shrinkwrap": null,
+  "_spec": "wcwidth@^1.0.0",
+  "_where": "/Users/zkat/Documents/code/npm/node_modules/columnify",
+  "author": {
+    "name": "Tim Oxley"
+  },
+  "bin": null,
+  "bugs": {
+    "url": "https://github.com/timoxley/wcwidth/issues"
+  },
+  "bundleDependencies": false,
+  "contributors": [
+    {
+      "name": "Woong Jun",
+      "email": "woong.jun@gmail.com",
+      "url": "http://code.woong.org/"
+    }
+  ],
+  "dependencies": {
+    "defaults": "^1.0.3"
+  },
+  "deprecated": false,
+  "description": "Port of C's wcwidth() and wcswidth()",
+  "devDependencies": {
+    "tape": "^4.5.1"
+  },
+  "directories": {
+    "doc": "docs",
+    "test": "test"
+  },
+  "homepage": "https://github.com/timoxley/wcwidth#readme",
+  "keywords": [
+    "wide character",
+    "wc",
+    "wide character string",
+    "wcs",
+    "terminal",
+    "width",
+    "wcwidth",
+    "wcswidth"
+  ],
+  "license": "MIT",
+  "main": "index.js",
+  "name": "wcwidth",
+  "optionalDependencies": {},
+  "peerDependencies": {},
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/timoxley/wcwidth.git"
+  },
+  "scripts": {
+    "test": "tape test/*.js"
+  },
+  "version": "1.0.1"
+}

package/node-v8.11.1-linux-x64/lib/node_modules/npm/node_modules/columnify/package.json

@@ -0,0 +1,81 @@
+{
+  "_from": "columnify@~1.5.4",
+  "_id": "columnify@1.5.4",
+  "_integrity": "sha1-Rzfd8ce2mop8NAVweC6UfuyOeLs=",
+  "_location": "/columnify",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "range",
+    "registry": true,
+    "raw": "columnify@~1.5.4",
+    "name": "columnify",
+    "escapedName": "columnify",
+    "rawSpec": "~1.5.4",
+    "saveSpec": null,
+    "fetchSpec": "~1.5.4"
+  },
+  "_requiredBy": [
+    "/"
+  ],
+  "_resolved": "https://registry.npmjs.org/columnify/-/columnify-1.5.4.tgz",
+  "_shasum": "4737ddf1c7b69a8a7c340570782e947eec8e78bb",
+  "_shrinkwrap": null,
+  "_spec": "columnify@~1.5.4",
+  "_where": "/Users/zkat/Documents/code/npm",
+  "author": {
+    "name": "Tim Oxley"
+  },
+  "babel": {
+    "presets": [
+      "es2015"
+    ]
+  },
+  "bin": null,
+  "bugs": {
+    "url": "https://github.com/timoxley/columnify/issues"
+  },
+  "bundleDependencies": false,
+  "dependencies": {
+    "strip-ansi": "^3.0.0",
+    "wcwidth": "^1.0.0"
+  },
+  "deprecated": false,
+  "description": "Render data in text columns. Supports in-column text-wrap.",
+  "devDependencies": {
+    "babel": "^6.3.26",
+    "babel-cli": "^6.3.17",
+    "babel-preset-es2015": "^6.3.13",
+    "chalk": "^1.1.1",
+    "tap-spec": "^4.1.1",
+    "tape": "^4.4.0"
+  },
+  "directories": {
+    "test": "test"
+  },
+  "homepage": "https://github.com/timoxley/columnify",
+  "keywords": [
+    "column",
+    "text",
+    "ansi",
+    "console",
+    "terminal",
+    "wrap",
+    "table"
+  ],
+  "license": "MIT",
+  "main": "columnify.js",
+  "name": "columnify",
+  "optionalDependencies": {},
+  "peerDependencies": {},
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/timoxley/columnify.git"
+  },
+  "scripts": {
+    "bench": "npm test && node bench",
+    "prepublish": "make prepublish",
+    "pretest": "npm prune",
+    "test": "make prepublish && tape test/*.js | tap-spec"
+  },
+  "version": "1.5.4"
+}

package/node-v8.11.1-linux-x64/lib/node_modules/npm/node_modules/columnify/utils.js

@@ -0,0 +1,193 @@
+"use strict"
+
+var wcwidth = require('./width')
+
+/**
+ * repeat string `str` up to total length of `len`
+ *
+ * @param String str string to repeat
+ * @param Number len total length of output string
+ */
+
+function repeatString(str, len) {
+  return Array.apply(null, {length: len + 1}).join(str).slice(0, len)
+}
+
+/**
+ * Pad `str` up to total length `max` with `chr`.
+ * If `str` is longer than `max`, padRight will return `str` unaltered.
+ *
+ * @param String str string to pad
+ * @param Number max total length of output string
+ * @param String chr optional. Character to pad with. default: ' '
+ * @return String padded str
+ */
+
+function padRight(str, max, chr) {
+  str = str != null ? str : ''
+  str = String(str)
+  var length = max - wcwidth(str)
+  if (length <= 0) return str
+  return str + repeatString(chr || ' ', length)
+}
+
+/**
+ * Pad `str` up to total length `max` with `chr`.
+ * If `str` is longer than `max`, padCenter will return `str` unaltered.
+ *
+ * @param String str string to pad
+ * @param Number max total length of output string
+ * @param String chr optional. Character to pad with. default: ' '
+ * @return String padded str
+ */
+
+function padCenter(str, max, chr) {
+  str = str != null ? str : ''
+  str = String(str)
+  var length = max - wcwidth(str)
+  if (length <= 0) return str
+  var lengthLeft = Math.floor(length/2)
+  var lengthRight = length - lengthLeft
+  return repeatString(chr || ' ', lengthLeft) + str + repeatString(chr || ' ', lengthRight)
+}
+
+/**
+ * Pad `str` up to total length `max` with `chr`, on the left.
+ * If `str` is longer than `max`, padRight will return `str` unaltered.
+ *
+ * @param String str string to pad
+ * @param Number max total length of output string
+ * @param String chr optional. Character to pad with. default: ' '
+ * @return String padded str
+ */
+
+function padLeft(str, max, chr) {
+  str = str != null ? str : ''
+  str = String(str)
+  var length = max - wcwidth(str)
+  if (length <= 0) return str
+  return repeatString(chr || ' ', length) + str
+}
+
+/**
+ * Split a String `str` into lines of maxiumum length `max`.
+ * Splits on word boundaries. Preserves existing new lines.
+ *
+ * @param String str string to split
+ * @param Number max length of each line
+ * @return Array Array containing lines.
+ */
+
+function splitIntoLines(str, max) {
+  function _splitIntoLines(str, max) {
+    return str.trim().split(' ').reduce(function(lines, word) {
+      var line = lines[lines.length - 1]
+      if (line && wcwidth(line.join(' ')) + wcwidth(word) < max) {
+        lines[lines.length - 1].push(word) // add to line
+      }
+      else lines.push([word]) // new line
+      return lines
+    }, []).map(function(l) {
+      return l.join(' ')
+    })
+  }
+  return str.split('\n').map(function(str) {
+    return _splitIntoLines(str, max)
+  }).reduce(function(lines, line) {
+    return lines.concat(line)
+  }, [])
+}
+
+/**
+ * Add spaces and `truncationChar` between words of
+ * `str` which are longer than `max`.
+ *
+ * @param String str string to split
+ * @param Number max length of each line
+ * @param Number truncationChar character to append to split words
+ * @return String
+ */
+
+function splitLongWords(str, max, truncationChar) {
+  str = str.trim()
+  var result = []
+  var words = str.split(' ')
+  var remainder = ''
+
+  var truncationWidth = wcwidth(truncationChar)
+
+  while (remainder || words.length) {
+    if (remainder) {
+      var word = remainder
+      remainder = ''
+    } else {
+      var word = words.shift()
+    }
+
+    if (wcwidth(word) > max) {
+      // slice is based on length no wcwidth
+      var i = 0
+      var wwidth = 0
+      var limit = max - truncationWidth
+      while (i < word.length) {
+        var w = wcwidth(word.charAt(i))
+        if (w + wwidth > limit) {
+          break
+        }
+        wwidth += w
+        ++i
+      }
+
+      remainder = word.slice(i) // get remainder
+      // save remainder for next loop
+
+      word = word.slice(0, i) // grab truncated word
+      word += truncationChar // add trailing … or whatever
+    }
+    result.push(word)
+  }
+
+  return result.join(' ')
+}
+
+
+/**
+ * Truncate `str` into total width `max`
+ * If `str` is shorter than `max`,  will return `str` unaltered.
+ *
+ * @param String str string to truncated
+ * @param Number max total wcwidth of output string
+ * @return String truncated str
+ */
+
+function truncateString(str, max) {
+
+  str = str != null ? str : ''
+  str = String(str)
+
+  if(max == Infinity) return str
+
+  var i = 0
+  var wwidth = 0
+  while (i < str.length) {
+    var w = wcwidth(str.charAt(i))
+    if(w + wwidth > max)
+      break
+    wwidth += w
+    ++i
+  }
+  return str.slice(0, i)
+}
+
+
+
+/**
+ * Exports
+ */
+
+module.exports.padRight = padRight
+module.exports.padCenter = padCenter
+module.exports.padLeft = padLeft
+module.exports.splitIntoLines = splitIntoLines
+module.exports.splitLongWords = splitLongWords
+module.exports.truncateString = truncateString

package/node-v8.11.1-linux-x64/lib/node_modules/npm/node_modules/columnify/width.js

@@ -0,0 +1,6 @@
+var stripAnsi = require('strip-ansi')
+var wcwidth = require('wcwidth')
+
+module.exports = function(str) {
+  return wcwidth(stripAnsi(str))
+}

package/node-v8.11.1-linux-x64/lib/node_modules/npm/node_modules/config-chain/.npmignore

@@ -0,0 +1,3 @@
+node_modules
+node_modules/*
+npm_debug.log

package/node-v8.11.1-linux-x64/lib/node_modules/npm/node_modules/config-chain/LICENCE

@@ -0,0 +1,22 @@
+Copyright (c) 2011 Dominic Tarr
+
+Permission is hereby granted, free of charge, 
+to any person obtaining a copy of this software and 
+associated documentation files (the "Software"), to 
+deal in the Software without restriction, including 
+without limitation the rights to use, copy, modify, 
+merge, publish, distribute, sublicense, and/or sell 
+copies of the Software, and to permit persons to whom 
+the Software is furnished to do so, 
+subject to the following conditions:
+
+The above copyright notice and this permission notice 
+shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES 
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR 
+ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, 
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE 
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.