@zuplo/cli 6.69.0 → 6.69.1

package/node_modules/printable-characters/package.json

@@ -1,72 +0,0 @@
-{
-  "name": "printable-characters",
-  "version": "1.0.42",
-  "description": "A little helper for handling strings containing zero width control characters, ANSI styling, whitespaces, newlines, 💩, etc.",
-  "main": "./build/printable-characters.js",
-  "scripts": {
-    "lint": "eslint printable-characters.js",
-    "lint-test": "eslint printable-characters.js",
-    "babel": "babel printable-characters.js --source-maps inline --out-file ./build/printable-characters.js",
-    "build": "npm run lint && npm run lint-test && npm run babel",
-    "test": "npm run build && env PRINTABLE_CHARACTERS_TEST_FILE=./build/printable-characters.js nyc --reporter=html --reporter=text mocha --reporter spec",
-    "autotest": "env PRINTABLE_CHARACTERS_TEST_FILE=./printable-characters.js mocha --reporter spec --watch",
-    "coveralls": "nyc report --reporter=text-lcov | coveralls"
-  },
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/xpl/printable-characters.git"
-  },
-  "keywords": [
-    "string width",
-    "string length",
-    "real string width",
-    "real string length",
-    "optical string width",
-    "printed width",
-    "unicode",
-    "codepoints",
-    "code points",
-    "strlen",
-    "zero width",
-    "zero width symbols",
-    "zero width characters",
-    "visible characters",
-    "visible symbols",
-    "visible",
-    "invisible",
-    "invisible symbols",
-    "invisible characters",
-    "printable",
-    "printable length",
-    "printable symbols",
-    "printable characters",
-    "non-printable characters",
-    "nonprintable characters",
-    "characters",
-    "symbols",
-    "string length",
-    "real string length",
-    "string trimming",
-    "trimming",
-    "escapes",
-    "escape codes",
-    "codes",
-    "ansi escapes",
-    "tokenizing",
-    "ansi",
-    "whitespaces"
-  ],
-  "author": "Vitaly Gordon <rocket.mind@gmail.com>",
-  "license": "Unlicense",
-  "homepage": "https://github.com/xpl/printable-characters",
-  "devDependencies": {
-    "babel-cli": "^6.26.0",
-    "babel-plugin-transform-es2015-block-scoped-functions": "^6.22.0",
-    "babel-plugin-transform-es2015-destructuring": "^6.23.0",
-    "coveralls": "^2.13.3",
-    "eslint": "^4.8.0",
-    "istanbul": "^0.4.5",
-    "mocha": "^3.5.3",
-    "nyc": "^11.2.1"
-  }
-}

package/node_modules/printable-characters/printable-characters.js

@@ -1,44 +0,0 @@
-"use strict";
-
-const ansiEscapeCode                   = '[\u001b\u009b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-PRZcf-nqry=><]'
-    , zeroWidthCharacterExceptNewline  = '\u0000-\u0008\u000B-\u0019\u001b\u009b\u00ad\u200b\u2028\u2029\ufeff\ufe00-\ufe0f'
-    , zeroWidthCharacter               = '\n' + zeroWidthCharacterExceptNewline
-    , zeroWidthCharactersExceptNewline = new RegExp ('(?:' + ansiEscapeCode + ')|[' + zeroWidthCharacterExceptNewline + ']', 'g')
-    , zeroWidthCharacters              = new RegExp ('(?:' + ansiEscapeCode + ')|[' + zeroWidthCharacter + ']', 'g')
-    , partition                        = new RegExp ('((?:' + ansiEscapeCode + ')|[\t' + zeroWidthCharacter + '])?([^\t' + zeroWidthCharacter + ']*)', 'g')
-
-module.exports = {
-
-    zeroWidthCharacters,
-
-    ansiEscapeCodes: new RegExp (ansiEscapeCode, 'g'),
-
-    strlen: s => Array.from (s.replace (zeroWidthCharacters, '')).length, // Array.from solves the emoji problem as described here: http://blog.jonnew.com/posts/poo-dot-length-equals-two
-
-    isBlank: s => s.replace (zeroWidthCharacters, '')
-                   .replace (/\s/g, '')
-                   .length === 0,
-
-    blank: s => Array.from (s.replace (zeroWidthCharactersExceptNewline, '')) // Array.from solves the emoji problem as described here: http://blog.jonnew.com/posts/poo-dot-length-equals-two
-                     .map (x => ((x === '\t') || (x === '\n')) ? x : ' ')
-                     .join (''),
-
-    partition (s) {
-        for (var m, spans = []; (partition.lastIndex !== s.length) && (m = partition.exec (s));) { spans.push ([m[1] || '', m[2]]) }
-        partition.lastIndex = 0 // reset
-        return spans
-    },
-
-    first (s, n) {
-
-        let result = '', length = 0
-
-        for (const [nonPrintable, printable] of module.exports.partition (s)) {
-            const text = Array.from (printable).slice (0, n - length) // Array.from solves the emoji problem as described here: http://blog.jonnew.com/posts/poo-dot-length-equals-two
-            result += nonPrintable + text.join ('')
-            length += text.length
-        }
-
-        return result
-    }
-}

package/node_modules/printable-characters/test.js

@@ -1,77 +0,0 @@
-"use strict";
-
-const assert              = require ('assert')
-const printableCharacters = require (process.env.PRINTABLE_CHARACTERS_TEST_FILE)
-
-// cannot use spread operator in tests due to Node v4 compatibility requirements...
-const strlen              = printableCharacters.strlen
-    , isBlank             = printableCharacters.isBlank
-    , blank               = printableCharacters.blank
-    , ansiEscapeCodes     = printableCharacters.ansiEscapeCodes
-    , zeroWidthCharacters = printableCharacters.zeroWidthCharacters
-    , partition           = printableCharacters.partition
-    , first               = printableCharacters.first
-
-describe ('printable-characters', () => {
-
-    it ('determines visible length', () => {
-
-        assert.equal (strlen ('💩'), 1)
-        //assert.equal (strlen ('👩‍❤️‍💋‍👩'), 1) // FAILING, see http://blog.jonnew.com/posts/poo-dot-length-equals-two for possible solution
-        assert.equal (strlen ('❤️'), 1)
-        assert.equal (strlen ('foo bar'), 7)
-        assert.equal (strlen ('\u001b[106mfoo bar\u001b[49m'), 7)
-    })
-
-    it ('detects blank text', () => {
-
-        assert (!isBlank ('💩'))
-        assert (!isBlank ('foobar'))
-        assert ( isBlank ('\u001b[106m  \t  \t   \n     \u001b[49m'))
-    })
-
-    it ('matches zero-width characters and ANSI escape codes', () => {
-
-        let s = '\u001b[106m' + 'foo' + '\n\n' + 'bar' + '\u001b[49m'
-
-        assert (s = s.replace (ansiEscapeCodes, ''), 'foo\n\nbar')
-        assert (    s.replace (zeroWidthCharacters, ''), 'foobar')
-    })
-
-    it ('obtains blank string of the same width', () => {
-
-        assert.equal (blank ('💩'), ' ')
-        //assert.equal (blank ('👩‍❤️‍💋‍👩'), ' ') // FAILING, see http://blog.jonnew.com/posts/poo-dot-length-equals-two for possible solution
-        assert.equal (blank ('❤️'), ' ')
-        assert.equal (blank ('foo'), '   ')
-        assert.equal (blank ('\n'), '\n')
-        assert.equal (blank ('\t'), '\t')
-        assert.equal (blank ('\tfoo \nfoo'), '\t    \n   ')
-        assert.equal (blank ('\u001b[22m\u001b[1mfoo \t\u001b[39m\u001b[22m'), '    \t')
-    })
-
-    it ('extracts invisible parts followed by visible ones', () => {
-
-        assert.deepEqual (partition (''),                        [                                                     ])
-        assert.deepEqual (partition ('foo'),                     [['',          'foo']                                 ])
-        assert.deepEqual (partition ('\u001b[1mfoo'),            [['\u001b[1m', 'foo']                                 ])
-        assert.deepEqual (partition ('\u001b[1mfoo\u0000bar'),   [['\u001b[1m', 'foo'],   ['\u0000', 'bar']            ])
-        assert.deepEqual (partition ('\u001b[1mfoo\u0000bar\n'), [['\u001b[1m', 'foo'],   ['\u0000', 'bar'], ['\n', '']])
-    })
-
-    it ('gets first N visible symbols (preserving invisible parts)', () => {
-   
-        assert.equal (first ('💩23456789', 0),   '')
-        assert.equal (first ('💩23456789', 3),   '💩23')
-        assert.equal (first ('💩23456789', 100), '💩23456789')
-
-        const s = '\u001b[22m\u001b[1m' + '💩23' + '\u0000' + '45' + '\u001b[39m' + '67' + '\n' + '89' + '\u001b[39m\u001b[22m'
-        
-        assert.equal (first (s, 0),   '\u001b[22m\u001b[1m' + ''    + '\u0000' + ''   + '\u001b[39m' + ''   + '\n' + ''   + '\u001b[39m\u001b[22m')
-        assert.equal (first (s, 3),   '\u001b[22m\u001b[1m' + '💩23' + '\u0000' + ''   + '\u001b[39m' + ''   + '\n' + ''   + '\u001b[39m\u001b[22m')
-        assert.equal (first (s, 4),   '\u001b[22m\u001b[1m' + '💩23' + '\u0000' + '4'  + '\u001b[39m' + ''   + '\n' + ''   + '\u001b[39m\u001b[22m')
-        assert.equal (first (s, 6),   '\u001b[22m\u001b[1m' + '💩23' + '\u0000' + '45' + '\u001b[39m' + '6'  + '\n' + ''   + '\u001b[39m\u001b[22m')
-        assert.equal (first (s, 9),   '\u001b[22m\u001b[1m' + '💩23' + '\u0000' + '45' + '\u001b[39m' + '67' + '\n' + '89' + '\u001b[39m\u001b[22m')
-        assert.equal (first (s, 100), '\u001b[22m\u001b[1m' + '💩23' + '\u0000' + '45' + '\u001b[39m' + '67' + '\n' + '89' + '\u001b[39m\u001b[22m')
-    })
-})