@vibedeckx/darwin-arm64 0.1.22 → 0.1.24

package/node_modules/minimist/index.js

@@ -1,263 +0,0 @@
-'use strict';
-
-function hasKey(obj, keys) {
-	var o = obj;
-	keys.slice(0, -1).forEach(function (key) {
-		o = o[key] || {};
-	});
-
-	var key = keys[keys.length - 1];
-	return key in o;
-}
-
-function isNumber(x) {
-	if (typeof x === 'number') { return true; }
-	if ((/^0x[0-9a-f]+$/i).test(x)) { return true; }
-	return (/^[-+]?(?:\d+(?:\.\d*)?|\.\d+)(e[-+]?\d+)?$/).test(x);
-}
-
-function isConstructorOrProto(obj, key) {
-	return (key === 'constructor' && typeof obj[key] === 'function') || key === '__proto__';
-}
-
-module.exports = function (args, opts) {
-	if (!opts) { opts = {}; }
-
-	var flags = {
-		bools: {},
-		strings: {},
-		unknownFn: null,
-	};
-
-	if (typeof opts.unknown === 'function') {
-		flags.unknownFn = opts.unknown;
-	}
-
-	if (typeof opts.boolean === 'boolean' && opts.boolean) {
-		flags.allBools = true;
-	} else {
-		[].concat(opts.boolean).filter(Boolean).forEach(function (key) {
-			flags.bools[key] = true;
-		});
-	}
-
-	var aliases = {};
-
-	function aliasIsBoolean(key) {
-		return aliases[key].some(function (x) {
-			return flags.bools[x];
-		});
-	}
-
-	Object.keys(opts.alias || {}).forEach(function (key) {
-		aliases[key] = [].concat(opts.alias[key]);
-		aliases[key].forEach(function (x) {
-			aliases[x] = [key].concat(aliases[key].filter(function (y) {
-				return x !== y;
-			}));
-		});
-	});
-
-	[].concat(opts.string).filter(Boolean).forEach(function (key) {
-		flags.strings[key] = true;
-		if (aliases[key]) {
-			[].concat(aliases[key]).forEach(function (k) {
-				flags.strings[k] = true;
-			});
-		}
-	});
-
-	var defaults = opts.default || {};
-
-	var argv = { _: [] };
-
-	function argDefined(key, arg) {
-		return (flags.allBools && (/^--[^=]+$/).test(arg))
-			|| flags.strings[key]
-			|| flags.bools[key]
-			|| aliases[key];
-	}
-
-	function setKey(obj, keys, value) {
-		var o = obj;
-		for (var i = 0; i < keys.length - 1; i++) {
-			var key = keys[i];
-			if (isConstructorOrProto(o, key)) { return; }
-			if (o[key] === undefined) { o[key] = {}; }
-			if (
-				o[key] === Object.prototype
-				|| o[key] === Number.prototype
-				|| o[key] === String.prototype
-			) {
-				o[key] = {};
-			}
-			if (o[key] === Array.prototype) { o[key] = []; }
-			o = o[key];
-		}
-
-		var lastKey = keys[keys.length - 1];
-		if (isConstructorOrProto(o, lastKey)) { return; }
-		if (
-			o === Object.prototype
-			|| o === Number.prototype
-			|| o === String.prototype
-		) {
-			o = {};
-		}
-		if (o === Array.prototype) { o = []; }
-		if (o[lastKey] === undefined || flags.bools[lastKey] || typeof o[lastKey] === 'boolean') {
-			o[lastKey] = value;
-		} else if (Array.isArray(o[lastKey])) {
-			o[lastKey].push(value);
-		} else {
-			o[lastKey] = [o[lastKey], value];
-		}
-	}
-
-	function setArg(key, val, arg) {
-		if (arg && flags.unknownFn && !argDefined(key, arg)) {
-			if (flags.unknownFn(arg) === false) { return; }
-		}
-
-		var value = !flags.strings[key] && isNumber(val)
-			? Number(val)
-			: val;
-		setKey(argv, key.split('.'), value);
-
-		(aliases[key] || []).forEach(function (x) {
-			setKey(argv, x.split('.'), value);
-		});
-	}
-
-	Object.keys(flags.bools).forEach(function (key) {
-		setArg(key, defaults[key] === undefined ? false : defaults[key]);
-	});
-
-	var notFlags = [];
-
-	if (args.indexOf('--') !== -1) {
-		notFlags = args.slice(args.indexOf('--') + 1);
-		args = args.slice(0, args.indexOf('--'));
-	}
-
-	for (var i = 0; i < args.length; i++) {
-		var arg = args[i];
-		var key;
-		var next;
-
-		if ((/^--.+=/).test(arg)) {
-			// Using [\s\S] instead of . because js doesn't support the
-			// 'dotall' regex modifier. See:
-			// http://stackoverflow.com/a/1068308/13216
-			var m = arg.match(/^--([^=]+)=([\s\S]*)$/);
-			key = m[1];
-			var value = m[2];
-			if (flags.bools[key]) {
-				value = value !== 'false';
-			}
-			setArg(key, value, arg);
-		} else if ((/^--no-.+/).test(arg)) {
-			key = arg.match(/^--no-(.+)/)[1];
-			setArg(key, false, arg);
-		} else if ((/^--.+/).test(arg)) {
-			key = arg.match(/^--(.+)/)[1];
-			next = args[i + 1];
-			if (
-				next !== undefined
-				&& !(/^(-|--)[^-]/).test(next)
-				&& !flags.bools[key]
-				&& !flags.allBools
-				&& (aliases[key] ? !aliasIsBoolean(key) : true)
-			) {
-				setArg(key, next, arg);
-				i += 1;
-			} else if ((/^(true|false)$/).test(next)) {
-				setArg(key, next === 'true', arg);
-				i += 1;
-			} else {
-				setArg(key, flags.strings[key] ? '' : true, arg);
-			}
-		} else if ((/^-[^-]+/).test(arg)) {
-			var letters = arg.slice(1, -1).split('');
-
-			var broken = false;
-			for (var j = 0; j < letters.length; j++) {
-				next = arg.slice(j + 2);
-
-				if (next === '-') {
-					setArg(letters[j], next, arg);
-					continue;
-				}
-
-				if ((/[A-Za-z]/).test(letters[j]) && next[0] === '=') {
-					setArg(letters[j], next.slice(1), arg);
-					broken = true;
-					break;
-				}
-
-				if (
-					(/[A-Za-z]/).test(letters[j])
-					&& (/-?\d+(\.\d*)?(e-?\d+)?$/).test(next)
-				) {
-					setArg(letters[j], next, arg);
-					broken = true;
-					break;
-				}
-
-				if (letters[j + 1] && letters[j + 1].match(/\W/)) {
-					setArg(letters[j], arg.slice(j + 2), arg);
-					broken = true;
-					break;
-				} else {
-					setArg(letters[j], flags.strings[letters[j]] ? '' : true, arg);
-				}
-			}
-
-			key = arg.slice(-1)[0];
-			if (!broken && key !== '-') {
-				if (
-					args[i + 1]
-					&& !(/^(-|--)[^-]/).test(args[i + 1])
-					&& !flags.bools[key]
-					&& (aliases[key] ? !aliasIsBoolean(key) : true)
-				) {
-					setArg(key, args[i + 1], arg);
-					i += 1;
-				} else if (args[i + 1] && (/^(true|false)$/).test(args[i + 1])) {
-					setArg(key, args[i + 1] === 'true', arg);
-					i += 1;
-				} else {
-					setArg(key, flags.strings[key] ? '' : true, arg);
-				}
-			}
-		} else {
-			if (!flags.unknownFn || flags.unknownFn(arg) !== false) {
-				argv._.push(flags.strings._ || !isNumber(arg) ? arg : Number(arg));
-			}
-			if (opts.stopEarly) {
-				argv._.push.apply(argv._, args.slice(i + 1));
-				break;
-			}
-		}
-	}
-
-	Object.keys(defaults).forEach(function (k) {
-		if (!hasKey(argv, k.split('.'))) {
-			setKey(argv, k.split('.'), defaults[k]);
-
-			(aliases[k] || []).forEach(function (x) {
-				setKey(argv, x.split('.'), defaults[k]);
-			});
-		}
-	});
-
-	if (opts['--']) {
-		argv['--'] = notFlags.slice();
-	} else {
-		notFlags.forEach(function (k) {
-			argv._.push(k);
-		});
-	}
-
-	return argv;
-};

package/node_modules/minimist/package.json

@@ -1,75 +0,0 @@
-{
-	"name": "minimist",
-	"version": "1.2.8",
-	"description": "parse argument options",
-	"main": "index.js",
-	"devDependencies": {
-		"@ljharb/eslint-config": "^21.0.1",
-		"aud": "^2.0.2",
-		"auto-changelog": "^2.4.0",
-		"eslint": "=8.8.0",
-		"in-publish": "^2.0.1",
-		"npmignore": "^0.3.0",
-		"nyc": "^10.3.2",
-		"safe-publish-latest": "^2.0.0",
-		"tape": "^5.6.3"
-	},
-	"scripts": {
-		"prepack": "npmignore --auto --commentLines=auto",
-		"prepublishOnly": "safe-publish-latest",
-		"prepublish": "not-in-publish || npm run prepublishOnly",
-		"lint": "eslint --ext=js,mjs .",
-		"pretest": "npm run lint",
-		"tests-only": "nyc tape 'test/**/*.js'",
-		"test": "npm run tests-only",
-		"posttest": "aud --production",
-		"version": "auto-changelog && git add CHANGELOG.md",
-		"postversion": "auto-changelog && git add CHANGELOG.md && git commit --no-edit --amend && git tag -f \"v$(node -e \"console.log(require('./package.json').version)\")\""
-	},
-	"testling": {
-		"files": "test/*.js",
-		"browsers": [
-			"ie/6..latest",
-			"ff/5",
-			"firefox/latest",
-			"chrome/10",
-			"chrome/latest",
-			"safari/5.1",
-			"safari/latest",
-			"opera/12"
-		]
-	},
-	"repository": {
-		"type": "git",
-		"url": "git://github.com/minimistjs/minimist.git"
-	},
-	"homepage": "https://github.com/minimistjs/minimist",
-	"keywords": [
-		"argv",
-		"getopt",
-		"parser",
-		"optimist"
-	],
-	"author": {
-		"name": "James Halliday",
-		"email": "mail@substack.net",
-		"url": "http://substack.net"
-	},
-	"funding": {
-		"url": "https://github.com/sponsors/ljharb"
-	},
-	"license": "MIT",
-	"auto-changelog": {
-		"output": "CHANGELOG.md",
-		"template": "keepachangelog",
-		"unreleased": false,
-		"commitLimit": false,
-		"backfillLimit": false,
-		"hideCredit": true
-	},
-	"publishConfig": {
-		"ignore": [
-			".github/workflows"
-		]
-	}
-}

package/node_modules/minimist/test/all_bool.js

@@ -1,34 +0,0 @@
-'use strict';
-
-var parse = require('../');
-var test = require('tape');
-
-test('flag boolean true (default all --args to boolean)', function (t) {
-	var argv = parse(['moo', '--honk', 'cow'], {
-		boolean: true,
-	});
-
-	t.deepEqual(argv, {
-		honk: true,
-		_: ['moo', 'cow'],
-	});
-
-	t.deepEqual(typeof argv.honk, 'boolean');
-	t.end();
-});
-
-test('flag boolean true only affects double hyphen arguments without equals signs', function (t) {
-	var argv = parse(['moo', '--honk', 'cow', '-p', '55', '--tacos=good'], {
-		boolean: true,
-	});
-
-	t.deepEqual(argv, {
-		honk: true,
-		tacos: 'good',
-		p: 55,
-		_: ['moo', 'cow'],
-	});
-
-	t.deepEqual(typeof argv.honk, 'boolean');
-	t.end();
-});

package/node_modules/minimist/test/bool.js

@@ -1,177 +0,0 @@
-'use strict';
-
-var parse = require('../');
-var test = require('tape');
-
-test('flag boolean default false', function (t) {
-	var argv = parse(['moo'], {
-		boolean: ['t', 'verbose'],
-		default: { verbose: false, t: false },
-	});
-
-	t.deepEqual(argv, {
-		verbose: false,
-		t: false,
-		_: ['moo'],
-	});
-
-	t.deepEqual(typeof argv.verbose, 'boolean');
-	t.deepEqual(typeof argv.t, 'boolean');
-	t.end();
-
-});
-
-test('boolean groups', function (t) {
-	var argv = parse(['-x', '-z', 'one', 'two', 'three'], {
-		boolean: ['x', 'y', 'z'],
-	});
-
-	t.deepEqual(argv, {
-		x: true,
-		y: false,
-		z: true,
-		_: ['one', 'two', 'three'],
-	});
-
-	t.deepEqual(typeof argv.x, 'boolean');
-	t.deepEqual(typeof argv.y, 'boolean');
-	t.deepEqual(typeof argv.z, 'boolean');
-	t.end();
-});
-test('boolean and alias with chainable api', function (t) {
-	var aliased = ['-h', 'derp'];
-	var regular = ['--herp', 'derp'];
-	var aliasedArgv = parse(aliased, {
-		boolean: 'herp',
-		alias: { h: 'herp' },
-	});
-	var propertyArgv = parse(regular, {
-		boolean: 'herp',
-		alias: { h: 'herp' },
-	});
-	var expected = {
-		herp: true,
-		h: true,
-		_: ['derp'],
-	};
-
-	t.same(aliasedArgv, expected);
-	t.same(propertyArgv, expected);
-	t.end();
-});
-
-test('boolean and alias with options hash', function (t) {
-	var aliased = ['-h', 'derp'];
-	var regular = ['--herp', 'derp'];
-	var opts = {
-		alias: { h: 'herp' },
-		boolean: 'herp',
-	};
-	var aliasedArgv = parse(aliased, opts);
-	var propertyArgv = parse(regular, opts);
-	var expected = {
-		herp: true,
-		h: true,
-		_: ['derp'],
-	};
-	t.same(aliasedArgv, expected);
-	t.same(propertyArgv, expected);
-	t.end();
-});
-
-test('boolean and alias array with options hash', function (t) {
-	var aliased = ['-h', 'derp'];
-	var regular = ['--herp', 'derp'];
-	var alt = ['--harp', 'derp'];
-	var opts = {
-		alias: { h: ['herp', 'harp'] },
-		boolean: 'h',
-	};
-	var aliasedArgv = parse(aliased, opts);
-	var propertyArgv = parse(regular, opts);
-	var altPropertyArgv = parse(alt, opts);
-	var expected = {
-		harp: true,
-		herp: true,
-		h: true,
-		_: ['derp'],
-	};
-	t.same(aliasedArgv, expected);
-	t.same(propertyArgv, expected);
-	t.same(altPropertyArgv, expected);
-	t.end();
-});
-
-test('boolean and alias using explicit true', function (t) {
-	var aliased = ['-h', 'true'];
-	var regular = ['--herp', 'true'];
-	var opts = {
-		alias: { h: 'herp' },
-		boolean: 'h',
-	};
-	var aliasedArgv = parse(aliased, opts);
-	var propertyArgv = parse(regular, opts);
-	var expected = {
-		herp: true,
-		h: true,
-		_: [],
-	};
-
-	t.same(aliasedArgv, expected);
-	t.same(propertyArgv, expected);
-	t.end();
-});
-
-// regression, see https://github.com/substack/node-optimist/issues/71
-test('boolean and --x=true', function (t) {
-	var parsed = parse(['--boool', '--other=true'], {
-		boolean: 'boool',
-	});
-
-	t.same(parsed.boool, true);
-	t.same(parsed.other, 'true');
-
-	parsed = parse(['--boool', '--other=false'], {
-		boolean: 'boool',
-	});
-
-	t.same(parsed.boool, true);
-	t.same(parsed.other, 'false');
-	t.end();
-});
-
-test('boolean --boool=true', function (t) {
-	var parsed = parse(['--boool=true'], {
-		default: {
-			boool: false,
-		},
-		boolean: ['boool'],
-	});
-
-	t.same(parsed.boool, true);
-	t.end();
-});
-
-test('boolean --boool=false', function (t) {
-	var parsed = parse(['--boool=false'], {
-		default: {
-			boool: true,
-		},
-		boolean: ['boool'],
-	});
-
-	t.same(parsed.boool, false);
-	t.end();
-});
-
-test('boolean using something similar to true', function (t) {
-	var opts = { boolean: 'h' };
-	var result = parse(['-h', 'true.txt'], opts);
-	var expected = {
-		h: true,
-		_: ['true.txt'],
-	};
-
-	t.same(result, expected);
-	t.end();
-});

package/node_modules/minimist/test/dash.js

@@ -1,43 +0,0 @@
-'use strict';
-
-var parse = require('../');
-var test = require('tape');
-
-test('-', function (t) {
-	t.plan(6);
-	t.deepEqual(parse(['-n', '-']), { n: '-', _: [] });
-	t.deepEqual(parse(['--nnn', '-']), { nnn: '-', _: [] });
-	t.deepEqual(parse(['-']), { _: ['-'] });
-	t.deepEqual(parse(['-f-']), { f: '-', _: [] });
-	t.deepEqual(
-		parse(['-b', '-'], { boolean: 'b' }),
-		{ b: true, _: ['-'] }
-	);
-	t.deepEqual(
-		parse(['-s', '-'], { string: 's' }),
-		{ s: '-', _: [] }
-	);
-});
-
-test('-a -- b', function (t) {
-	t.plan(2);
-	t.deepEqual(parse(['-a', '--', 'b']), { a: true, _: ['b'] });
-	t.deepEqual(parse(['--a', '--', 'b']), { a: true, _: ['b'] });
-});
-
-test('move arguments after the -- into their own `--` array', function (t) {
-	t.plan(1);
-	t.deepEqual(
-		parse(['--name', 'John', 'before', '--', 'after'], { '--': true }),
-		{ name: 'John', _: ['before'], '--': ['after'] }
-	);
-});
-
-test('--- option value', function (t) {
-	// A multi-dash value is largely an edge case, but check the behaviour is as expected,
-	// and in particular the same for short option and long option (as made consistent in Jan 2023).
-	t.plan(2);
-	t.deepEqual(parse(['-n', '---']), { n: '---', _: [] });
-	t.deepEqual(parse(['--nnn', '---']), { nnn: '---', _: [] });
-});
-

package/node_modules/minimist/test/default_bool.js

@@ -1,37 +0,0 @@
-'use strict';
-
-var test = require('tape');
-var parse = require('../');
-
-test('boolean default true', function (t) {
-	var argv = parse([], {
-		boolean: 'sometrue',
-		default: { sometrue: true },
-	});
-	t.equal(argv.sometrue, true);
-	t.end();
-});
-
-test('boolean default false', function (t) {
-	var argv = parse([], {
-		boolean: 'somefalse',
-		default: { somefalse: false },
-	});
-	t.equal(argv.somefalse, false);
-	t.end();
-});
-
-test('boolean default to null', function (t) {
-	var argv = parse([], {
-		boolean: 'maybe',
-		default: { maybe: null },
-	});
-	t.equal(argv.maybe, null);
-
-	var argvLong = parse(['--maybe'], {
-		boolean: 'maybe',
-		default: { maybe: null },
-	});
-	t.equal(argvLong.maybe, true);
-	t.end();
-});

package/node_modules/minimist/test/dotted.js

@@ -1,24 +0,0 @@
-'use strict';
-
-var parse = require('../');
-var test = require('tape');
-
-test('dotted alias', function (t) {
-	var argv = parse(['--a.b', '22'], { default: { 'a.b': 11 }, alias: { 'a.b': 'aa.bb' } });
-	t.equal(argv.a.b, 22);
-	t.equal(argv.aa.bb, 22);
-	t.end();
-});
-
-test('dotted default', function (t) {
-	var argv = parse('', { default: { 'a.b': 11 }, alias: { 'a.b': 'aa.bb' } });
-	t.equal(argv.a.b, 11);
-	t.equal(argv.aa.bb, 11);
-	t.end();
-});
-
-test('dotted default with no alias', function (t) {
-	var argv = parse('', { default: { 'a.b': 11 } });
-	t.equal(argv.a.b, 11);
-	t.end();
-});

package/node_modules/minimist/test/kv_short.js

@@ -1,32 +0,0 @@
-'use strict';
-
-var parse = require('../');
-var test = require('tape');
-
-test('short -k=v', function (t) {
-	t.plan(1);
-
-	var argv = parse(['-b=123']);
-	t.deepEqual(argv, { b: 123, _: [] });
-});
-
-test('multi short -k=v', function (t) {
-	t.plan(1);
-
-	var argv = parse(['-a=whatever', '-b=robots']);
-	t.deepEqual(argv, { a: 'whatever', b: 'robots', _: [] });
-});
-
-test('short with embedded equals -k=a=b', function (t) {
-	t.plan(1);
-
-	var argv = parse(['-k=a=b']);
-	t.deepEqual(argv, { k: 'a=b', _: [] });
-});
-
-test('short with later equals like -ab=c', function (t) {
-	t.plan(1);
-
-	var argv = parse(['-ab=c']);
-	t.deepEqual(argv, { a: true, b: 'c', _: [] });
-});