appmap 0.72.2 → 0.72.3

data/node_modules/yargs/build/lib/utils/apply-extends.js

@@ -1,59 +0,0 @@
-import { YError } from '../yerror.js';
-let previouslyVisitedConfigs = [];
-let shim;
-export function applyExtends(config, cwd, mergeExtends, _shim) {
-    shim = _shim;
-    let defaultConfig = {};
-    if (Object.prototype.hasOwnProperty.call(config, 'extends')) {
-        if (typeof config.extends !== 'string')
-            return defaultConfig;
-        const isPath = /\.json|\..*rc$/.test(config.extends);
-        let pathToDefault = null;
-        if (!isPath) {
-            try {
-                pathToDefault = require.resolve(config.extends);
-            }
-            catch (_err) {
-                return config;
-            }
-        }
-        else {
-            pathToDefault = getPathToDefaultConfig(cwd, config.extends);
-        }
-        checkForCircularExtends(pathToDefault);
-        previouslyVisitedConfigs.push(pathToDefault);
-        defaultConfig = isPath
-            ? JSON.parse(shim.readFileSync(pathToDefault, 'utf8'))
-            : require(config.extends);
-        delete config.extends;
-        defaultConfig = applyExtends(defaultConfig, shim.path.dirname(pathToDefault), mergeExtends, shim);
-    }
-    previouslyVisitedConfigs = [];
-    return mergeExtends
-        ? mergeDeep(defaultConfig, config)
-        : Object.assign({}, defaultConfig, config);
-}
-function checkForCircularExtends(cfgPath) {
-    if (previouslyVisitedConfigs.indexOf(cfgPath) > -1) {
-        throw new YError(`Circular extended configurations: '${cfgPath}'.`);
-    }
-}
-function getPathToDefaultConfig(cwd, pathToExtend) {
-    return shim.path.resolve(cwd, pathToExtend);
-}
-function mergeDeep(config1, config2) {
-    const target = {};
-    function isObject(obj) {
-        return obj && typeof obj === 'object' && !Array.isArray(obj);
-    }
-    Object.assign(target, config1);
-    for (const key of Object.keys(config2)) {
-        if (isObject(config2[key]) && isObject(target[key])) {
-            target[key] = mergeDeep(config1[key], config2[key]);
-        }
-        else {
-            target[key] = config2[key];
-        }
-    }
-    return target;
-}

data/node_modules/yargs/build/lib/utils/is-promise.js

@@ -1,5 +0,0 @@
-export function isPromise(maybePromise) {
-    return (!!maybePromise &&
-        !!maybePromise.then &&
-        typeof maybePromise.then === 'function');
-}

data/node_modules/yargs/build/lib/utils/levenshtein.js

@@ -1,26 +0,0 @@
-export function levenshtein(a, b) {
-    if (a.length === 0)
-        return b.length;
-    if (b.length === 0)
-        return a.length;
-    const matrix = [];
-    let i;
-    for (i = 0; i <= b.length; i++) {
-        matrix[i] = [i];
-    }
-    let j;
-    for (j = 0; j <= a.length; j++) {
-        matrix[0][j] = j;
-    }
-    for (i = 1; i <= b.length; i++) {
-        for (j = 1; j <= a.length; j++) {
-            if (b.charAt(i - 1) === a.charAt(j - 1)) {
-                matrix[i][j] = matrix[i - 1][j - 1];
-            }
-            else {
-                matrix[i][j] = Math.min(matrix[i - 1][j - 1] + 1, Math.min(matrix[i][j - 1] + 1, matrix[i - 1][j] + 1));
-            }
-        }
-    }
-    return matrix[b.length][a.length];
-}

data/node_modules/yargs/build/lib/utils/maybe-async-result.js

@@ -1,17 +0,0 @@
-import { isPromise } from './is-promise.js';
-export function maybeAsyncResult(getResult, resultHandler, errorHandler = (err) => {
-    throw err;
-}) {
-    try {
-        const result = isFunction(getResult) ? getResult() : getResult;
-        return isPromise(result)
-            ? result.then((result) => resultHandler(result))
-            : resultHandler(result);
-    }
-    catch (err) {
-        return errorHandler(err);
-    }
-}
-function isFunction(arg) {
-    return typeof arg === 'function';
-}

data/node_modules/yargs/build/lib/utils/obj-filter.js

@@ -1,10 +0,0 @@
-import { objectKeys } from '../typings/common-types.js';
-export function objFilter(original = {}, filter = () => true) {
-    const obj = {};
-    objectKeys(original).forEach(key => {
-        if (filter(key, original[key])) {
-            obj[key] = original[key];
-        }
-    });
-    return obj;
-}

data/node_modules/yargs/build/lib/utils/process-argv.js

@@ -1,17 +0,0 @@
-function getProcessArgvBinIndex() {
-    if (isBundledElectronApp())
-        return 0;
-    return 1;
-}
-function isBundledElectronApp() {
-    return isElectronApp() && !process.defaultApp;
-}
-function isElectronApp() {
-    return !!process.versions.electron;
-}
-export function hideBin(argv) {
-    return argv.slice(getProcessArgvBinIndex() + 1);
-}
-export function getProcessArgvBin() {
-    return process.argv[getProcessArgvBinIndex()];
-}

data/node_modules/yargs/build/lib/utils/set-blocking.js

@@ -1,12 +0,0 @@
-export default function setBlocking(blocking) {
-    if (typeof process === 'undefined')
-        return;
-    [process.stdout, process.stderr].forEach(_stream => {
-        const stream = _stream;
-        if (stream._handle &&
-            stream.isTTY &&
-            typeof stream._handle.setBlocking === 'function') {
-            stream._handle.setBlocking(blocking);
-        }
-    });
-}

data/node_modules/yargs/build/lib/utils/which-module.js

@@ -1,10 +0,0 @@
-export default function whichModule(exported) {
-    if (typeof require === 'undefined')
-        return null;
-    for (let i = 0, files = Object.keys(require.cache), mod; i < files.length; i++) {
-        mod = require.cache[files[i]];
-        if (mod.exports === exported)
-            return mod;
-    }
-    return null;
-}

data/node_modules/yargs/build/lib/validation.js

@@ -1,279 +0,0 @@
-import { argsert } from './argsert.js';
-import { assertNotStrictEqual, } from './typings/common-types.js';
-import { levenshtein as distance } from './utils/levenshtein.js';
-import { objFilter } from './utils/obj-filter.js';
-const specialKeys = ['$0', '--', '_'];
-export function validation(yargs, usage, shim) {
-    const __ = shim.y18n.__;
-    const __n = shim.y18n.__n;
-    const self = {};
-    self.nonOptionCount = function nonOptionCount(argv) {
-        const demandedCommands = yargs.getDemandedCommands();
-        const positionalCount = argv._.length + (argv['--'] ? argv['--'].length : 0);
-        const _s = positionalCount - yargs.getInternalMethods().getContext().commands.length;
-        if (demandedCommands._ &&
-            (_s < demandedCommands._.min || _s > demandedCommands._.max)) {
-            if (_s < demandedCommands._.min) {
-                if (demandedCommands._.minMsg !== undefined) {
-                    usage.fail(demandedCommands._.minMsg
-                        ? demandedCommands._.minMsg
-                            .replace(/\$0/g, _s.toString())
-                            .replace(/\$1/, demandedCommands._.min.toString())
-                        : null);
-                }
-                else {
-                    usage.fail(__n('Not enough non-option arguments: got %s, need at least %s', 'Not enough non-option arguments: got %s, need at least %s', _s, _s.toString(), demandedCommands._.min.toString()));
-                }
-            }
-            else if (_s > demandedCommands._.max) {
-                if (demandedCommands._.maxMsg !== undefined) {
-                    usage.fail(demandedCommands._.maxMsg
-                        ? demandedCommands._.maxMsg
-                            .replace(/\$0/g, _s.toString())
-                            .replace(/\$1/, demandedCommands._.max.toString())
-                        : null);
-                }
-                else {
-                    usage.fail(__n('Too many non-option arguments: got %s, maximum of %s', 'Too many non-option arguments: got %s, maximum of %s', _s, _s.toString(), demandedCommands._.max.toString()));
-                }
-            }
-        }
-    };
-    self.positionalCount = function positionalCount(required, observed) {
-        if (observed < required) {
-            usage.fail(__n('Not enough non-option arguments: got %s, need at least %s', 'Not enough non-option arguments: got %s, need at least %s', observed, observed + '', required + ''));
-        }
-    };
-    self.requiredArguments = function requiredArguments(argv, demandedOptions) {
-        let missing = null;
-        for (const key of Object.keys(demandedOptions)) {
-            if (!Object.prototype.hasOwnProperty.call(argv, key) ||
-                typeof argv[key] === 'undefined') {
-                missing = missing || {};
-                missing[key] = demandedOptions[key];
-            }
-        }
-        if (missing) {
-            const customMsgs = [];
-            for (const key of Object.keys(missing)) {
-                const msg = missing[key];
-                if (msg && customMsgs.indexOf(msg) < 0) {
-                    customMsgs.push(msg);
-                }
-            }
-            const customMsg = customMsgs.length ? `\n${customMsgs.join('\n')}` : '';
-            usage.fail(__n('Missing required argument: %s', 'Missing required arguments: %s', Object.keys(missing).length, Object.keys(missing).join(', ') + customMsg));
-        }
-    };
-    self.unknownArguments = function unknownArguments(argv, aliases, positionalMap, isDefaultCommand, checkPositionals = true) {
-        const commandKeys = yargs
-            .getInternalMethods()
-            .getCommandInstance()
-            .getCommands();
-        const unknown = [];
-        const currentContext = yargs.getInternalMethods().getContext();
-        Object.keys(argv).forEach(key => {
-            if (specialKeys.indexOf(key) === -1 &&
-                !Object.prototype.hasOwnProperty.call(positionalMap, key) &&
-                !Object.prototype.hasOwnProperty.call(yargs.getInternalMethods().getParseContext(), key) &&
-                !self.isValidAndSomeAliasIsNotNew(key, aliases)) {
-                unknown.push(key);
-            }
-        });
-        if (checkPositionals &&
-            (currentContext.commands.length > 0 ||
-                commandKeys.length > 0 ||
-                isDefaultCommand)) {
-            argv._.slice(currentContext.commands.length).forEach(key => {
-                if (commandKeys.indexOf('' + key) === -1) {
-                    unknown.push('' + key);
-                }
-            });
-        }
-        if (unknown.length > 0) {
-            usage.fail(__n('Unknown argument: %s', 'Unknown arguments: %s', unknown.length, unknown.join(', ')));
-        }
-    };
-    self.unknownCommands = function unknownCommands(argv) {
-        const commandKeys = yargs
-            .getInternalMethods()
-            .getCommandInstance()
-            .getCommands();
-        const unknown = [];
-        const currentContext = yargs.getInternalMethods().getContext();
-        if (currentContext.commands.length > 0 || commandKeys.length > 0) {
-            argv._.slice(currentContext.commands.length).forEach(key => {
-                if (commandKeys.indexOf('' + key) === -1) {
-                    unknown.push('' + key);
-                }
-            });
-        }
-        if (unknown.length > 0) {
-            usage.fail(__n('Unknown command: %s', 'Unknown commands: %s', unknown.length, unknown.join(', ')));
-            return true;
-        }
-        else {
-            return false;
-        }
-    };
-    self.isValidAndSomeAliasIsNotNew = function isValidAndSomeAliasIsNotNew(key, aliases) {
-        if (!Object.prototype.hasOwnProperty.call(aliases, key)) {
-            return false;
-        }
-        const newAliases = yargs.parsed.newAliases;
-        return [key, ...aliases[key]].some(a => !Object.prototype.hasOwnProperty.call(newAliases, a) || !newAliases[key]);
-    };
-    self.limitedChoices = function limitedChoices(argv) {
-        const options = yargs.getOptions();
-        const invalid = {};
-        if (!Object.keys(options.choices).length)
-            return;
-        Object.keys(argv).forEach(key => {
-            if (specialKeys.indexOf(key) === -1 &&
-                Object.prototype.hasOwnProperty.call(options.choices, key)) {
-                [].concat(argv[key]).forEach(value => {
-                    if (options.choices[key].indexOf(value) === -1 &&
-                        value !== undefined) {
-                        invalid[key] = (invalid[key] || []).concat(value);
-                    }
-                });
-            }
-        });
-        const invalidKeys = Object.keys(invalid);
-        if (!invalidKeys.length)
-            return;
-        let msg = __('Invalid values:');
-        invalidKeys.forEach(key => {
-            msg += `\n  ${__('Argument: %s, Given: %s, Choices: %s', key, usage.stringifiedValues(invalid[key]), usage.stringifiedValues(options.choices[key]))}`;
-        });
-        usage.fail(msg);
-    };
-    let implied = {};
-    self.implies = function implies(key, value) {
-        argsert('<string|object> [array|number|string]', [key, value], arguments.length);
-        if (typeof key === 'object') {
-            Object.keys(key).forEach(k => {
-                self.implies(k, key[k]);
-            });
-        }
-        else {
-            yargs.global(key);
-            if (!implied[key]) {
-                implied[key] = [];
-            }
-            if (Array.isArray(value)) {
-                value.forEach(i => self.implies(key, i));
-            }
-            else {
-                assertNotStrictEqual(value, undefined, shim);
-                implied[key].push(value);
-            }
-        }
-    };
-    self.getImplied = function getImplied() {
-        return implied;
-    };
-    function keyExists(argv, val) {
-        const num = Number(val);
-        val = isNaN(num) ? val : num;
-        if (typeof val === 'number') {
-            val = argv._.length >= val;
-        }
-        else if (val.match(/^--no-.+/)) {
-            val = val.match(/^--no-(.+)/)[1];
-            val = !argv[val];
-        }
-        else {
-            val = argv[val];
-        }
-        return val;
-    }
-    self.implications = function implications(argv) {
-        const implyFail = [];
-        Object.keys(implied).forEach(key => {
-            const origKey = key;
-            (implied[key] || []).forEach(value => {
-                let key = origKey;
-                const origValue = value;
-                key = keyExists(argv, key);
-                value = keyExists(argv, value);
-                if (key && !value) {
-                    implyFail.push(` ${origKey} -> ${origValue}`);
-                }
-            });
-        });
-        if (implyFail.length) {
-            let msg = `${__('Implications failed:')}\n`;
-            implyFail.forEach(value => {
-                msg += value;
-            });
-            usage.fail(msg);
-        }
-    };
-    let conflicting = {};
-    self.conflicts = function conflicts(key, value) {
-        argsert('<string|object> [array|string]', [key, value], arguments.length);
-        if (typeof key === 'object') {
-            Object.keys(key).forEach(k => {
-                self.conflicts(k, key[k]);
-            });
-        }
-        else {
-            yargs.global(key);
-            if (!conflicting[key]) {
-                conflicting[key] = [];
-            }
-            if (Array.isArray(value)) {
-                value.forEach(i => self.conflicts(key, i));
-            }
-            else {
-                conflicting[key].push(value);
-            }
-        }
-    };
-    self.getConflicting = () => conflicting;
-    self.conflicting = function conflictingFn(argv) {
-        Object.keys(argv).forEach(key => {
-            if (conflicting[key]) {
-                conflicting[key].forEach(value => {
-                    if (value && argv[key] !== undefined && argv[value] !== undefined) {
-                        usage.fail(__('Arguments %s and %s are mutually exclusive', key, value));
-                    }
-                });
-            }
-        });
-    };
-    self.recommendCommands = function recommendCommands(cmd, potentialCommands) {
-        const threshold = 3;
-        potentialCommands = potentialCommands.sort((a, b) => b.length - a.length);
-        let recommended = null;
-        let bestDistance = Infinity;
-        for (let i = 0, candidate; (candidate = potentialCommands[i]) !== undefined; i++) {
-            const d = distance(cmd, candidate);
-            if (d <= threshold && d < bestDistance) {
-                bestDistance = d;
-                recommended = candidate;
-            }
-        }
-        if (recommended)
-            usage.fail(__('Did you mean %s?', recommended));
-    };
-    self.reset = function reset(localLookup) {
-        implied = objFilter(implied, k => !localLookup[k]);
-        conflicting = objFilter(conflicting, k => !localLookup[k]);
-        return self;
-    };
-    const frozens = [];
-    self.freeze = function freeze() {
-        frozens.push({
-            implied,
-            conflicting,
-        });
-    };
-    self.unfreeze = function unfreeze() {
-        const frozen = frozens.pop();
-        assertNotStrictEqual(frozen, undefined, shim);
-        ({ implied, conflicting } = frozen);
-    };
-    return self;
-}