@walkhi/code-relax 0.1.0-beta.1

package/node_modules/yargs/build/lib/completion.d.ts

@@ -0,0 +1,21 @@
+import { CommandInstance } from './command';
+import { UsageInstance } from './usage';
+import { YargsInstance } from './yargs';
+import { Arguments, DetailedArguments } from 'yargs-parser';
+export declare function completion(yargs: YargsInstance, usage: UsageInstance, command: CommandInstance): CompletionInstance;
+/** Instance of the completion module. */
+export interface CompletionInstance {
+    completionKey: string;
+    generateCompletionScript($0: string, cmd: string): string;
+    getCompletion(args: string[], done: (completions: string[]) => any): any;
+    registerFunction(fn: CompletionFunction): void;
+    setParsed(parsed: DetailedArguments): void;
+}
+export declare type CompletionFunction = SyncCompletionFunction | AsyncCompletionFunction;
+interface SyncCompletionFunction {
+    (current: string, argv: Arguments): string[] | Promise<string[]>;
+}
+interface AsyncCompletionFunction {
+    (current: string, argv: Arguments, done: (completions: string[]) => any): any;
+}
+export {};

package/node_modules/yargs/build/lib/completion.js

@@ -0,0 +1,135 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.completion = void 0;
+const command_1 = require("./command");
+const templates = require("./completion-templates");
+const is_promise_1 = require("./is-promise");
+const parse_command_1 = require("./parse-command");
+const path = require("path");
+const common_types_1 = require("./common-types");
+// add bash completions to your
+//  yargs-powered applications.
+function completion(yargs, usage, command) {
+    const self = {
+        completionKey: 'get-yargs-completions'
+    };
+    let aliases;
+    self.setParsed = function setParsed(parsed) {
+        aliases = parsed.aliases;
+    };
+    const zshShell = (process.env.SHELL && process.env.SHELL.indexOf('zsh') !== -1) ||
+        (process.env.ZSH_NAME && process.env.ZSH_NAME.indexOf('zsh') !== -1);
+    // get a list of completion commands.
+    // 'args' is the array of strings from the line to be completed
+    self.getCompletion = function getCompletion(args, done) {
+        const completions = [];
+        const current = args.length ? args[args.length - 1] : '';
+        const argv = yargs.parse(args, true);
+        const parentCommands = yargs.getContext().commands;
+        // a custom completion function can be provided
+        // to completion().
+        function runCompletionFunction(argv) {
+            common_types_1.assertNotStrictEqual(completionFunction, null);
+            if (isSyncCompletionFunction(completionFunction)) {
+                const result = completionFunction(current, argv);
+                // promise based completion function.
+                if (is_promise_1.isPromise(result)) {
+                    return result.then((list) => {
+                        process.nextTick(() => { done(list); });
+                    }).catch((err) => {
+                        process.nextTick(() => { throw err; });
+                    });
+                }
+                // synchronous completion function.
+                return done(result);
+            }
+            else {
+                // asynchronous completion function
+                return completionFunction(current, argv, (completions) => {
+                    done(completions);
+                });
+            }
+        }
+        if (completionFunction) {
+            return is_promise_1.isPromise(argv) ? argv.then(runCompletionFunction) : runCompletionFunction(argv);
+        }
+        const handlers = command.getCommandHandlers();
+        for (let i = 0, ii = args.length; i < ii; ++i) {
+            if (handlers[args[i]] && handlers[args[i]].builder) {
+                const builder = handlers[args[i]].builder;
+                if (command_1.isCommandBuilderCallback(builder)) {
+                    const y = yargs.reset();
+                    builder(y);
+                    return y.argv;
+                }
+            }
+        }
+        if (!current.match(/^-/) && parentCommands[parentCommands.length - 1] !== current) {
+            usage.getCommands().forEach((usageCommand) => {
+                const commandName = parse_command_1.parseCommand(usageCommand[0]).cmd;
+                if (args.indexOf(commandName) === -1) {
+                    if (!zshShell) {
+                        completions.push(commandName);
+                    }
+                    else {
+                        const desc = usageCommand[1] || '';
+                        completions.push(commandName.replace(/:/g, '\\:') + ':' + desc);
+                    }
+                }
+            });
+        }
+        if (current.match(/^-/) || (current === '' && completions.length === 0)) {
+            const descs = usage.getDescriptions();
+            const options = yargs.getOptions();
+            Object.keys(options.key).forEach((key) => {
+                const negable = !!options.configuration['boolean-negation'] && options.boolean.includes(key);
+                // If the key and its aliases aren't in 'args', add the key to 'completions'
+                let keyAndAliases = [key].concat(aliases[key] || []);
+                if (negable)
+                    keyAndAliases = keyAndAliases.concat(keyAndAliases.map(key => `no-${key}`));
+                function completeOptionKey(key) {
+                    const notInArgs = keyAndAliases.every(val => args.indexOf(`--${val}`) === -1);
+                    if (notInArgs) {
+                        const startsByTwoDashes = (s) => /^--/.test(s);
+                        const isShortOption = (s) => /^[^0-9]$/.test(s);
+                        const dashes = !startsByTwoDashes(current) && isShortOption(key) ? '-' : '--';
+                        if (!zshShell) {
+                            completions.push(dashes + key);
+                        }
+                        else {
+                            const desc = descs[key] || '';
+                            completions.push(dashes + `${key.replace(/:/g, '\\:')}:${desc.replace('__yargsString__:', '')}`);
+                        }
+                    }
+                }
+                completeOptionKey(key);
+                if (negable && !!options.default[key])
+                    completeOptionKey(`no-${key}`);
+            });
+        }
+        done(completions);
+    };
+    // generate the completion script to add to your .bashrc.
+    self.generateCompletionScript = function generateCompletionScript($0, cmd) {
+        let script = zshShell ? templates.completionZshTemplate : templates.completionShTemplate;
+        const name = path.basename($0);
+        // add ./to applications not yet installed as bin.
+        if ($0.match(/\.js$/))
+            $0 = `./${$0}`;
+        script = script.replace(/{{app_name}}/g, name);
+        script = script.replace(/{{completion_command}}/g, cmd);
+        return script.replace(/{{app_path}}/g, $0);
+    };
+    // register a function to perform your own custom
+    // completions., this function can be either
+    // synchrnous or asynchronous.
+    let completionFunction = null;
+    self.registerFunction = (fn) => {
+        completionFunction = fn;
+    };
+    return self;
+}
+exports.completion = completion;
+function isSyncCompletionFunction(completionFunction) {
+    return completionFunction.length < 3;
+}

package/node_modules/yargs/build/lib/is-promise.d.ts

@@ -0,0 +1 @@
+export declare function isPromise<T>(maybePromise: T | Promise<T>): maybePromise is Promise<T>;

package/node_modules/yargs/build/lib/is-promise.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isPromise = void 0;
+function isPromise(maybePromise) {
+    return !!maybePromise &&
+        !!maybePromise.then &&
+        (typeof maybePromise.then === 'function');
+}
+exports.isPromise = isPromise;

package/node_modules/yargs/build/lib/levenshtein.d.ts

@@ -0,0 +1 @@
+export declare function levenshtein(a: string, b: string): number;

package/node_modules/yargs/build/lib/levenshtein.js

@@ -0,0 +1,58 @@
+"use strict";
+/*
+Copyright (c) 2011 Andrei Mackenzie
+
+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.
+*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.levenshtein = void 0;
+// levenshtein distance algorithm, pulled from Andrei Mackenzie's MIT licensed.
+// gist, which can be found here: https://gist.github.com/andrei-m/982927
+// Compute the edit distance between the two given strings
+function levenshtein(a, b) {
+    if (a.length === 0)
+        return b.length;
+    if (b.length === 0)
+        return a.length;
+    const matrix = [];
+    // increment along the first column of each row
+    let i;
+    for (i = 0; i <= b.length; i++) {
+        matrix[i] = [i];
+    }
+    // increment each column in the first row
+    let j;
+    for (j = 0; j <= a.length; j++) {
+        matrix[0][j] = j;
+    }
+    // Fill in the rest of the matrix
+    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, // substitution
+                Math.min(matrix[i][j - 1] + 1, // insertion
+                matrix[i - 1][j] + 1)); // deletion
+            }
+        }
+    }
+    return matrix[b.length][a.length];
+}
+exports.levenshtein = levenshtein;

package/node_modules/yargs/build/lib/middleware.d.ts

@@ -0,0 +1,10 @@
+import { YargsInstance, Arguments } from './yargs';
+export declare function globalMiddlewareFactory<T>(globalMiddleware: Middleware[], context: T): (callback: MiddlewareCallback | MiddlewareCallback[], applyBeforeValidation?: boolean) => T;
+export declare function commandMiddlewareFactory(commandMiddleware?: MiddlewareCallback[]): Middleware[];
+export declare function applyMiddleware(argv: Arguments | Promise<Arguments>, yargs: YargsInstance, middlewares: Middleware[], beforeValidation: boolean): Arguments | Promise<Arguments>;
+export interface MiddlewareCallback {
+    (argv: Arguments, yargs: YargsInstance): Partial<Arguments> | Promise<Partial<Arguments>>;
+}
+export interface Middleware extends MiddlewareCallback {
+    applyBeforeValidation: boolean;
+}

package/node_modules/yargs/build/lib/middleware.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyMiddleware = exports.commandMiddlewareFactory = exports.globalMiddlewareFactory = void 0;
+const argsert_1 = require("./argsert");
+const is_promise_1 = require("./is-promise");
+function globalMiddlewareFactory(globalMiddleware, context) {
+    return function (callback, applyBeforeValidation = false) {
+        argsert_1.argsert('<array|function> [boolean]', [callback, applyBeforeValidation], arguments.length);
+        if (Array.isArray(callback)) {
+            for (let i = 0; i < callback.length; i++) {
+                if (typeof callback[i] !== 'function') {
+                    throw Error('middleware must be a function');
+                }
+                callback[i].applyBeforeValidation = applyBeforeValidation;
+            }
+            Array.prototype.push.apply(globalMiddleware, callback);
+        }
+        else if (typeof callback === 'function') {
+            callback.applyBeforeValidation = applyBeforeValidation;
+            globalMiddleware.push(callback);
+        }
+        return context;
+    };
+}
+exports.globalMiddlewareFactory = globalMiddlewareFactory;
+function commandMiddlewareFactory(commandMiddleware) {
+    if (!commandMiddleware)
+        return [];
+    return commandMiddleware.map(middleware => {
+        middleware.applyBeforeValidation = false;
+        return middleware;
+    });
+}
+exports.commandMiddlewareFactory = commandMiddlewareFactory;
+function applyMiddleware(argv, yargs, middlewares, beforeValidation) {
+    const beforeValidationError = new Error('middleware cannot return a promise when applyBeforeValidation is true');
+    return middlewares
+        .reduce((acc, middleware) => {
+        if (middleware.applyBeforeValidation !== beforeValidation) {
+            return acc;
+        }
+        if (is_promise_1.isPromise(acc)) {
+            return acc
+                .then(initialObj => Promise.all([initialObj, middleware(initialObj, yargs)]))
+                .then(([initialObj, middlewareObj]) => Object.assign(initialObj, middlewareObj));
+        }
+        else {
+            const result = middleware(acc, yargs);
+            if (beforeValidation && is_promise_1.isPromise(result))
+                throw beforeValidationError;
+            return is_promise_1.isPromise(result)
+                ? result.then(middlewareObj => Object.assign(acc, middlewareObj))
+                : Object.assign(acc, result);
+        }
+    }, argv);
+}
+exports.applyMiddleware = applyMiddleware;

package/node_modules/yargs/build/lib/obj-filter.d.ts

@@ -0,0 +1 @@
+export declare function objFilter<T extends object>(original?: T, filter?: (k: keyof T, v: T[keyof T]) => boolean): T;

package/node_modules/yargs/build/lib/obj-filter.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.objFilter = void 0;
+const common_types_1 = require("./common-types");
+function objFilter(original = {}, filter = () => true) {
+    const obj = {};
+    common_types_1.objectKeys(original).forEach((key) => {
+        if (filter(key, original[key])) {
+            obj[key] = original[key];
+        }
+    });
+    return obj;
+}
+exports.objFilter = objFilter;

package/node_modules/yargs/build/lib/parse-command.d.ts

@@ -0,0 +1,11 @@
+import { NotEmptyArray } from './common-types';
+export declare function parseCommand(cmd: string): ParsedCommand;
+export interface ParsedCommand {
+    cmd: string;
+    demanded: Positional[];
+    optional: Positional[];
+}
+export interface Positional {
+    cmd: NotEmptyArray<string>;
+    variadic: boolean;
+}

package/node_modules/yargs/build/lib/parse-command.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseCommand = void 0;
+function parseCommand(cmd) {
+    const extraSpacesStrippedCommand = cmd.replace(/\s{2,}/g, ' ');
+    const splitCommand = extraSpacesStrippedCommand.split(/\s+(?![^[]*]|[^<]*>)/);
+    const bregex = /\.*[\][<>]/g;
+    const firstCommand = splitCommand.shift();
+    if (!firstCommand)
+        throw new Error(`No command found in: ${cmd}`);
+    const parsedCommand = {
+        cmd: firstCommand.replace(bregex, ''),
+        demanded: [],
+        optional: []
+    };
+    splitCommand.forEach((cmd, i) => {
+        let variadic = false;
+        cmd = cmd.replace(/\s/g, '');
+        if (/\.+[\]>]/.test(cmd) && i === splitCommand.length - 1)
+            variadic = true;
+        if (/^\[/.test(cmd)) {
+            parsedCommand.optional.push({
+                cmd: cmd.replace(bregex, '').split('|'),
+                variadic
+            });
+        }
+        else {
+            parsedCommand.demanded.push({
+                cmd: cmd.replace(bregex, '').split('|'),
+                variadic
+            });
+        }
+    });
+    return parsedCommand;
+}
+exports.parseCommand = parseCommand;

package/node_modules/yargs/build/lib/process-argv.d.ts

@@ -0,0 +1,2 @@
+export declare function getProcessArgvWithoutBin(): string[];
+export declare function getProcessArgvBin(): string;

package/node_modules/yargs/build/lib/process-argv.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getProcessArgvBin = exports.getProcessArgvWithoutBin = void 0;
+function getProcessArgvBinIndex() {
+    // The binary name is the first command line argument for:
+    // - bundled Electron apps: bin argv1 argv2 ... argvn
+    if (isBundledElectronApp())
+        return 0;
+    // or the second one (default) for:
+    // - standard node apps: node bin.js argv1 argv2 ... argvn
+    // - unbundled Electron apps: electron bin.js argv1 arg2 ... argvn
+    return 1;
+}
+function isBundledElectronApp() {
+    // process.defaultApp is either set by electron in an electron unbundled app, or undefined
+    // see https://github.com/electron/electron/blob/master/docs/api/process.md#processdefaultapp-readonly
+    return isElectronApp() && !process.defaultApp;
+}
+function isElectronApp() {
+    // process.versions.electron is either set by electron, or undefined
+    // see https://github.com/electron/electron/blob/master/docs/api/process.md#processversionselectron-readonly
+    return !!process.versions.electron;
+}
+function getProcessArgvWithoutBin() {
+    return process.argv.slice(getProcessArgvBinIndex() + 1);
+}
+exports.getProcessArgvWithoutBin = getProcessArgvWithoutBin;
+function getProcessArgvBin() {
+    return process.argv[getProcessArgvBinIndex()];
+}
+exports.getProcessArgvBin = getProcessArgvBin;

package/node_modules/yargs/build/lib/usage.d.ts

@@ -0,0 +1,49 @@
+import { Dictionary } from './common-types';
+import { YargsInstance } from './yargs';
+import { YError } from './yerror';
+import { Y18N } from 'y18n';
+export declare function usage(yargs: YargsInstance, y18n: Y18N): UsageInstance;
+/** Instance of the usage module. */
+export interface UsageInstance {
+    cacheHelpMessage(): void;
+    clearCachedHelpMessage(): void;
+    command(cmd: string, description: string | undefined, isDefault: boolean, aliases: string[], deprecated?: boolean): void;
+    deferY18nLookup(str: string): string;
+    describe(keys: string | string[] | Dictionary<string>, desc?: string): void;
+    epilog(msg: string): void;
+    example(cmd: string, description?: string): void;
+    fail(msg?: string | null, err?: YError | string): void;
+    failFn(f: FailureFunction): void;
+    freeze(): void;
+    functionDescription(fn: {
+        name?: string;
+    }): string;
+    getCommands(): [string, string, boolean, string[], boolean][];
+    getDescriptions(): Dictionary<string | undefined>;
+    getPositionalGroupName(): string;
+    getUsage(): [string, string][];
+    getUsageDisabled(): boolean;
+    help(): string;
+    reset(localLookup: Dictionary<boolean>): UsageInstance;
+    showHelp(level: 'error' | 'log' | ((message: string) => void)): void;
+    showHelpOnFail(enabled?: boolean | string, message?: string): UsageInstance;
+    showVersion(): void;
+    stringifiedValues(values?: any[], separator?: string): string;
+    unfreeze(): void;
+    usage(msg: string | null, description?: string | false): UsageInstance;
+    version(ver: any): void;
+    wrap(cols: number | null | undefined): void;
+}
+export interface FailureFunction {
+    (msg: string | undefined | null, err: YError | string | undefined, usage: UsageInstance): void;
+}
+export interface FrozenUsageInstance {
+    failMessage: string | undefined | null;
+    failureOutput: boolean;
+    usages: [string, string][];
+    usageDisabled: boolean;
+    epilogs: string[];
+    examples: [string, string][];
+    commands: [string, string, boolean, string[], boolean][];
+    descriptions: Dictionary<string | undefined>;
+}