bloby-bot 0.26.1 → 0.27.1

package/workspace/node_modules/minimist/test/long.js

@@ -1,33 +0,0 @@
-'use strict';
-
-var test = require('tape');
-var parse = require('../');
-
-test('long opts', function (t) {
-	t.deepEqual(
-		parse(['--bool']),
-		{ bool: true, _: [] },
-		'long boolean'
-	);
-	t.deepEqual(
-		parse(['--pow', 'xixxle']),
-		{ pow: 'xixxle', _: [] },
-		'long capture sp'
-	);
-	t.deepEqual(
-		parse(['--pow=xixxle']),
-		{ pow: 'xixxle', _: [] },
-		'long capture eq'
-	);
-	t.deepEqual(
-		parse(['--host', 'localhost', '--port', '555']),
-		{ host: 'localhost', port: 555, _: [] },
-		'long captures sp'
-	);
-	t.deepEqual(
-		parse(['--host=localhost', '--port=555']),
-		{ host: 'localhost', port: 555, _: [] },
-		'long captures eq'
-	);
-	t.end();
-});

package/workspace/node_modules/minimist/test/num.js

@@ -1,38 +0,0 @@
-'use strict';
-
-var parse = require('../');
-var test = require('tape');
-
-test('nums', function (t) {
-	var argv = parse([
-		'-x', '1234',
-		'-y', '5.67',
-		'-z', '1e7',
-		'-w', '10f',
-		'--hex', '0xdeadbeef',
-		'789',
-	]);
-	t.deepEqual(argv, {
-		x: 1234,
-		y: 5.67,
-		z: 1e7,
-		w: '10f',
-		hex: 0xdeadbeef,
-		_: [789],
-	});
-	t.deepEqual(typeof argv.x, 'number');
-	t.deepEqual(typeof argv.y, 'number');
-	t.deepEqual(typeof argv.z, 'number');
-	t.deepEqual(typeof argv.w, 'string');
-	t.deepEqual(typeof argv.hex, 'number');
-	t.deepEqual(typeof argv._[0], 'number');
-	t.end();
-});
-
-test('already a number', function (t) {
-	var argv = parse(['-x', 1234, 789]);
-	t.deepEqual(argv, { x: 1234, _: [789] });
-	t.deepEqual(typeof argv.x, 'number');
-	t.deepEqual(typeof argv._[0], 'number');
-	t.end();
-});

package/workspace/node_modules/minimist/test/parse.js

@@ -1,209 +0,0 @@
-'use strict';
-
-var parse = require('../');
-var test = require('tape');
-
-test('parse args', function (t) {
-	t.deepEqual(
-		parse(['--no-moo']),
-		{ moo: false, _: [] },
-		'no'
-	);
-	t.deepEqual(
-		parse(['-v', 'a', '-v', 'b', '-v', 'c']),
-		{ v: ['a', 'b', 'c'], _: [] },
-		'multi'
-	);
-	t.end();
-});
-
-test('comprehensive', function (t) {
-	t.deepEqual(
-		parse([
-			'--name=meowmers', 'bare', '-cats', 'woo',
-			'-h', 'awesome', '--multi=quux',
-			'--key', 'value',
-			'-b', '--bool', '--no-meep', '--multi=baz',
-			'--', '--not-a-flag', 'eek',
-		]),
-		{
-			c: true,
-			a: true,
-			t: true,
-			s: 'woo',
-			h: 'awesome',
-			b: true,
-			bool: true,
-			key: 'value',
-			multi: ['quux', 'baz'],
-			meep: false,
-			name: 'meowmers',
-			_: ['bare', '--not-a-flag', 'eek'],
-		}
-	);
-	t.end();
-});
-
-test('flag boolean', function (t) {
-	var argv = parse(['-t', 'moo'], { boolean: 't' });
-	t.deepEqual(argv, { t: true, _: ['moo'] });
-	t.deepEqual(typeof argv.t, 'boolean');
-	t.end();
-});
-
-test('flag boolean value', function (t) {
-	var argv = parse(['--verbose', 'false', 'moo', '-t', 'true'], {
-		boolean: ['t', 'verbose'],
-		default: { verbose: true },
-	});
-
-	t.deepEqual(argv, {
-		verbose: false,
-		t: true,
-		_: ['moo'],
-	});
-
-	t.deepEqual(typeof argv.verbose, 'boolean');
-	t.deepEqual(typeof argv.t, 'boolean');
-	t.end();
-});
-
-test('newlines in params', function (t) {
-	var args = parse(['-s', 'X\nX']);
-	t.deepEqual(args, { _: [], s: 'X\nX' });
-
-	// reproduce in bash:
-	// VALUE="new
-	// line"
-	// node program.js --s="$VALUE"
-	args = parse(['--s=X\nX']);
-	t.deepEqual(args, { _: [], s: 'X\nX' });
-	t.end();
-});
-
-test('strings', function (t) {
-	var s = parse(['-s', '0001234'], { string: 's' }).s;
-	t.equal(s, '0001234');
-	t.equal(typeof s, 'string');
-
-	var x = parse(['-x', '56'], { string: 'x' }).x;
-	t.equal(x, '56');
-	t.equal(typeof x, 'string');
-	t.end();
-});
-
-test('stringArgs', function (t) {
-	var s = parse(['  ', '  '], { string: '_' })._;
-	t.same(s.length, 2);
-	t.same(typeof s[0], 'string');
-	t.same(s[0], '  ');
-	t.same(typeof s[1], 'string');
-	t.same(s[1], '  ');
-	t.end();
-});
-
-test('empty strings', function (t) {
-	var s = parse(['-s'], { string: 's' }).s;
-	t.equal(s, '');
-	t.equal(typeof s, 'string');
-
-	var str = parse(['--str'], { string: 'str' }).str;
-	t.equal(str, '');
-	t.equal(typeof str, 'string');
-
-	var letters = parse(['-art'], {
-		string: ['a', 't'],
-	});
-
-	t.equal(letters.a, '');
-	t.equal(letters.r, true);
-	t.equal(letters.t, '');
-
-	t.end();
-});
-
-test('string and alias', function (t) {
-	var x = parse(['--str', '000123'], {
-		string: 's',
-		alias: { s: 'str' },
-	});
-
-	t.equal(x.str, '000123');
-	t.equal(typeof x.str, 'string');
-	t.equal(x.s, '000123');
-	t.equal(typeof x.s, 'string');
-
-	var y = parse(['-s', '000123'], {
-		string: 'str',
-		alias: { str: 's' },
-	});
-
-	t.equal(y.str, '000123');
-	t.equal(typeof y.str, 'string');
-	t.equal(y.s, '000123');
-	t.equal(typeof y.s, 'string');
-
-	var z = parse(['-s123'], {
-		alias: { str: ['s', 'S'] },
-		string: ['str'],
-	});
-
-	t.deepEqual(
-		z,
-		{ _: [], s: '123', S: '123', str: '123' },
-		'opt.string works with multiple aliases'
-	);
-	t.end();
-});
-
-test('slashBreak', function (t) {
-	t.same(
-		parse(['-I/foo/bar/baz']),
-		{ I: '/foo/bar/baz', _: [] }
-	);
-	t.same(
-		parse(['-xyz/foo/bar/baz']),
-		{ x: true, y: true, z: '/foo/bar/baz', _: [] }
-	);
-	t.end();
-});
-
-test('alias', function (t) {
-	var argv = parse(['-f', '11', '--zoom', '55'], {
-		alias: { z: 'zoom' },
-	});
-	t.equal(argv.zoom, 55);
-	t.equal(argv.z, argv.zoom);
-	t.equal(argv.f, 11);
-	t.end();
-});
-
-test('multiAlias', function (t) {
-	var argv = parse(['-f', '11', '--zoom', '55'], {
-		alias: { z: ['zm', 'zoom'] },
-	});
-	t.equal(argv.zoom, 55);
-	t.equal(argv.z, argv.zoom);
-	t.equal(argv.z, argv.zm);
-	t.equal(argv.f, 11);
-	t.end();
-});
-
-test('nested dotted objects', function (t) {
-	var argv = parse([
-		'--foo.bar', '3', '--foo.baz', '4',
-		'--foo.quux.quibble', '5', '--foo.quux.o_O',
-		'--beep.boop',
-	]);
-
-	t.same(argv.foo, {
-		bar: 3,
-		baz: 4,
-		quux: {
-			quibble: 5,
-			o_O: true,
-		},
-	});
-	t.same(argv.beep, { boop: true });
-	t.end();
-});

package/workspace/node_modules/minimist/test/parse_modified.js

@@ -1,11 +0,0 @@
-'use strict';
-
-var parse = require('../');
-var test = require('tape');
-
-test('parse with modifier functions', function (t) {
-	t.plan(1);
-
-	var argv = parse(['-b', '123'], { boolean: 'b' });
-	t.deepEqual(argv, { b: true, _: [123] });
-});

package/workspace/node_modules/minimist/test/proto.js

@@ -1,64 +0,0 @@
-'use strict';
-
-/* eslint no-proto: 0 */
-
-var parse = require('../');
-var test = require('tape');
-
-test('proto pollution', function (t) {
-	var argv = parse(['--__proto__.x', '123']);
-	t.equal({}.x, undefined);
-	t.equal(argv.__proto__.x, undefined);
-	t.equal(argv.x, undefined);
-	t.end();
-});
-
-test('proto pollution (array)', function (t) {
-	var argv = parse(['--x', '4', '--x', '5', '--x.__proto__.z', '789']);
-	t.equal({}.z, undefined);
-	t.deepEqual(argv.x, [4, 5]);
-	t.equal(argv.x.z, undefined);
-	t.equal(argv.x.__proto__.z, undefined);
-	t.end();
-});
-
-test('proto pollution (number)', function (t) {
-	var argv = parse(['--x', '5', '--x.__proto__.z', '100']);
-	t.equal({}.z, undefined);
-	t.equal((4).z, undefined);
-	t.equal(argv.x, 5);
-	t.equal(argv.x.z, undefined);
-	t.end();
-});
-
-test('proto pollution (string)', function (t) {
-	var argv = parse(['--x', 'abc', '--x.__proto__.z', 'def']);
-	t.equal({}.z, undefined);
-	t.equal('...'.z, undefined);
-	t.equal(argv.x, 'abc');
-	t.equal(argv.x.z, undefined);
-	t.end();
-});
-
-test('proto pollution (constructor)', function (t) {
-	var argv = parse(['--constructor.prototype.y', '123']);
-	t.equal({}.y, undefined);
-	t.equal(argv.y, undefined);
-	t.end();
-});
-
-test('proto pollution (constructor function)', function (t) {
-	var argv = parse(['--_.concat.constructor.prototype.y', '123']);
-	function fnToBeTested() {}
-	t.equal(fnToBeTested.y, undefined);
-	t.equal(argv.y, undefined);
-	t.end();
-});
-
-// powered by snyk - https://github.com/backstage/backstage/issues/10343
-test('proto pollution (constructor function) snyk', function (t) {
-	var argv = parse('--_.constructor.constructor.prototype.foo bar'.split(' '));
-	t.equal(function () {}.foo, undefined);
-	t.equal(argv.y, undefined);
-	t.end();
-});

package/workspace/node_modules/minimist/test/short.js

@@ -1,69 +0,0 @@
-'use strict';
-
-var parse = require('../');
-var test = require('tape');
-
-test('numeric short args', function (t) {
-	t.plan(2);
-	t.deepEqual(parse(['-n123']), { n: 123, _: [] });
-	t.deepEqual(
-		parse(['-123', '456']),
-		{ 1: true, 2: true, 3: 456, _: [] }
-	);
-});
-
-test('short', function (t) {
-	t.deepEqual(
-		parse(['-b']),
-		{ b: true, _: [] },
-		'short boolean'
-	);
-	t.deepEqual(
-		parse(['foo', 'bar', 'baz']),
-		{ _: ['foo', 'bar', 'baz'] },
-		'bare'
-	);
-	t.deepEqual(
-		parse(['-cats']),
-		{ c: true, a: true, t: true, s: true, _: [] },
-		'group'
-	);
-	t.deepEqual(
-		parse(['-cats', 'meow']),
-		{ c: true, a: true, t: true, s: 'meow', _: [] },
-		'short group next'
-	);
-	t.deepEqual(
-		parse(['-h', 'localhost']),
-		{ h: 'localhost', _: [] },
-		'short capture'
-	);
-	t.deepEqual(
-		parse(['-h', 'localhost', '-p', '555']),
-		{ h: 'localhost', p: 555, _: [] },
-		'short captures'
-	);
-	t.end();
-});
-
-test('mixed short bool and capture', function (t) {
-	t.same(
-		parse(['-h', 'localhost', '-fp', '555', 'script.js']),
-		{
-			f: true, p: 555, h: 'localhost',
-			_: ['script.js'],
-		}
-	);
-	t.end();
-});
-
-test('short and long', function (t) {
-	t.deepEqual(
-		parse(['-h', 'localhost', '-fp', '555', 'script.js']),
-		{
-			f: true, p: 555, h: 'localhost',
-			_: ['script.js'],
-		}
-	);
-	t.end();
-});

package/workspace/node_modules/minimist/test/stop_early.js

@@ -1,17 +0,0 @@
-'use strict';
-
-var parse = require('../');
-var test = require('tape');
-
-test('stops parsing on the first non-option when stopEarly is set', function (t) {
-	var argv = parse(['--aaa', 'bbb', 'ccc', '--ddd'], {
-		stopEarly: true,
-	});
-
-	t.deepEqual(argv, {
-		aaa: 'bbb',
-		_: ['ccc', '--ddd'],
-	});
-
-	t.end();
-});

package/workspace/node_modules/minimist/test/unknown.js

@@ -1,104 +0,0 @@
-'use strict';
-
-var parse = require('../');
-var test = require('tape');
-
-test('boolean and alias is not unknown', function (t) {
-	var unknown = [];
-	function unknownFn(arg) {
-		unknown.push(arg);
-		return false;
-	}
-	var aliased = ['-h', 'true', '--derp', 'true'];
-	var regular = ['--herp', 'true', '-d', 'true'];
-	var opts = {
-		alias: { h: 'herp' },
-		boolean: 'h',
-		unknown: unknownFn,
-	};
-	parse(aliased, opts);
-	parse(regular, opts);
-
-	t.same(unknown, ['--derp', '-d']);
-	t.end();
-});
-
-test('flag boolean true any double hyphen argument is not unknown', function (t) {
-	var unknown = [];
-	function unknownFn(arg) {
-		unknown.push(arg);
-		return false;
-	}
-	var argv = parse(['--honk', '--tacos=good', 'cow', '-p', '55'], {
-		boolean: true,
-		unknown: unknownFn,
-	});
-	t.same(unknown, ['--tacos=good', 'cow', '-p']);
-	t.same(argv, {
-		honk: true,
-		_: [],
-	});
-	t.end();
-});
-
-test('string and alias is not unknown', function (t) {
-	var unknown = [];
-	function unknownFn(arg) {
-		unknown.push(arg);
-		return false;
-	}
-	var aliased = ['-h', 'hello', '--derp', 'goodbye'];
-	var regular = ['--herp', 'hello', '-d', 'moon'];
-	var opts = {
-		alias: { h: 'herp' },
-		string: 'h',
-		unknown: unknownFn,
-	};
-	parse(aliased, opts);
-	parse(regular, opts);
-
-	t.same(unknown, ['--derp', '-d']);
-	t.end();
-});
-
-test('default and alias is not unknown', function (t) {
-	var unknown = [];
-	function unknownFn(arg) {
-		unknown.push(arg);
-		return false;
-	}
-	var aliased = ['-h', 'hello'];
-	var regular = ['--herp', 'hello'];
-	var opts = {
-		default: { h: 'bar' },
-		alias: { h: 'herp' },
-		unknown: unknownFn,
-	};
-	parse(aliased, opts);
-	parse(regular, opts);
-
-	t.same(unknown, []);
-	t.end();
-	unknownFn(); // exercise fn for 100% coverage
-});
-
-test('value following -- is not unknown', function (t) {
-	var unknown = [];
-	function unknownFn(arg) {
-		unknown.push(arg);
-		return false;
-	}
-	var aliased = ['--bad', '--', 'good', 'arg'];
-	var opts = {
-		'--': true,
-		unknown: unknownFn,
-	};
-	var argv = parse(aliased, opts);
-
-	t.same(unknown, ['--bad']);
-	t.same(argv, {
-		'--': ['good', 'arg'],
-		_: [],
-	});
-	t.end();
-});

package/workspace/node_modules/minimist/test/whitespace.js

@@ -1,10 +0,0 @@
-'use strict';
-
-var parse = require('../');
-var test = require('tape');
-
-test('whitespace should be whitespace', function (t) {
-	t.plan(1);
-	var x = parse(['-x', '\t']).x;
-	t.equal(x, '\t');
-});

package/workspace/node_modules/mkdirp-classic/LICENSE

@@ -1,21 +0,0 @@
-The MIT License (MIT)
-
-Copyright (c) 2020 James Halliday (mail@substack.net) and Mathias Buus
-
-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.

package/workspace/node_modules/mkdirp-classic/README.md

@@ -1,18 +0,0 @@
-# mkdirp-classic
-
-Just a non-deprecated mirror of [mkdirp 0.5.2](https://github.com/substack/node-mkdirp/tree/0.5.1)
-for use in modules where we depend on the non promise interface.
-
-```
-npm install mkdirp-classic
-```
-
-## Usage
-
-``` js
-// See the above link
-```
-
-## License
-
-MIT

package/workspace/node_modules/mkdirp-classic/index.js

@@ -1,98 +0,0 @@
-var path = require('path');
-var fs = require('fs');
-var _0777 = parseInt('0777', 8);
-
-module.exports = mkdirP.mkdirp = mkdirP.mkdirP = mkdirP;
-
-function mkdirP (p, opts, f, made) {
-    if (typeof opts === 'function') {
-        f = opts;
-        opts = {};
-    }
-    else if (!opts || typeof opts !== 'object') {
-        opts = { mode: opts };
-    }
-    
-    var mode = opts.mode;
-    var xfs = opts.fs || fs;
-    
-    if (mode === undefined) {
-        mode = _0777 & (~process.umask());
-    }
-    if (!made) made = null;
-    
-    var cb = f || function () {};
-    p = path.resolve(p);
-    
-    xfs.mkdir(p, mode, function (er) {
-        if (!er) {
-            made = made || p;
-            return cb(null, made);
-        }
-        switch (er.code) {
-            case 'ENOENT':
-                mkdirP(path.dirname(p), opts, function (er, made) {
-                    if (er) cb(er, made);
-                    else mkdirP(p, opts, cb, made);
-                });
-                break;
-
-            // In the case of any other error, just see if there's a dir
-            // there already.  If so, then hooray!  If not, then something
-            // is borked.
-            default:
-                xfs.stat(p, function (er2, stat) {
-                    // if the stat fails, then that's super weird.
-                    // let the original error be the failure reason.
-                    if (er2 || !stat.isDirectory()) cb(er, made)
-                    else cb(null, made);
-                });
-                break;
-        }
-    });
-}
-
-mkdirP.sync = function sync (p, opts, made) {
-    if (!opts || typeof opts !== 'object') {
-        opts = { mode: opts };
-    }
-    
-    var mode = opts.mode;
-    var xfs = opts.fs || fs;
-    
-    if (mode === undefined) {
-        mode = _0777 & (~process.umask());
-    }
-    if (!made) made = null;
-
-    p = path.resolve(p);
-
-    try {
-        xfs.mkdirSync(p, mode);
-        made = made || p;
-    }
-    catch (err0) {
-        switch (err0.code) {
-            case 'ENOENT' :
-                made = sync(path.dirname(p), opts, made);
-                sync(p, opts, made);
-                break;
-
-            // In the case of any other error, just see if there's a dir
-            // there already.  If so, then hooray!  If not, then something
-            // is borked.
-            default:
-                var stat;
-                try {
-                    stat = xfs.statSync(p);
-                }
-                catch (err1) {
-                    throw err0;
-                }
-                if (!stat.isDirectory()) throw err0;
-                break;
-        }
-    }
-
-    return made;
-};