initial status

node_modules/listr2/dist/utils/assert.d.ts

@@ -0,0 +1,6 @@
+/**
+ * This function asserts the given value as a function or itself.
+ * If the value itself is a function it will evaluate it with the passed in arguments,
+ * elsewise it will directly return itself.
+ */
+export declare function assertFunctionOrSelf<T>(functionOrSelf: T, ...args: T extends (...args: any[]) => any ? Parameters<T> : never): T extends (...args: any[]) => any ? ReturnType<T> : T;

node_modules/listr2/dist/utils/assert.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertFunctionOrSelf = void 0;
+/**
+ * This function asserts the given value as a function or itself.
+ * If the value itself is a function it will evaluate it with the passed in arguments,
+ * elsewise it will directly return itself.
+ */
+function assertFunctionOrSelf(functionOrSelf, ...args) {
+    if (typeof functionOrSelf === 'function') {
+        return functionOrSelf(...args);
+    }
+    else {
+        return functionOrSelf;
+    }
+}
+exports.assertFunctionOrSelf = assertFunctionOrSelf;

node_modules/listr2/dist/utils/colorette.d.ts

@@ -0,0 +1,2 @@
+import * as colorette from 'colorette';
+export default colorette;

node_modules/listr2/dist/utils/colorette.js

@@ -0,0 +1,10 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+const colorette = require("colorette");
+/* istanbul ignore if */
+if (((_a = process.env) === null || _a === void 0 ? void 0 : _a.LISTR_DISABLE_COLOR) === '1') {
+    // disable coloring completely
+    colorette.options.enabled = false;
+}
+exports.default = colorette;

node_modules/listr2/dist/utils/figures.d.ts

@@ -0,0 +1,12 @@
+export declare const figures: {
+    warning: string;
+    cross: string;
+    arrowDown: string;
+    tick: string;
+    arrowRight: string;
+    pointer: string;
+    checkboxOn: string;
+    arrowLeft: string;
+    squareSmallFilled: string;
+    pointerSmall: string;
+};

node_modules/listr2/dist/utils/figures.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.figures = void 0;
+const is_unicode_supported_1 = require("./is-unicode-supported");
+const FIGURES_MAIN = {
+    warning: '⚠',
+    cross: '✖',
+    arrowDown: '↓',
+    tick: '✔',
+    arrowRight: '→',
+    pointer: '❯',
+    checkboxOn: '☒',
+    arrowLeft: '←',
+    squareSmallFilled: '◼',
+    pointerSmall: '›'
+};
+const FIGURES_FALLBACK = {
+    ...FIGURES_MAIN,
+    warning: '‼',
+    cross: '×',
+    tick: '√',
+    pointer: '>',
+    checkboxOn: '[×]',
+    squareSmallFilled: '■'
+};
+exports.figures = is_unicode_supported_1.isUnicodeSupported ? FIGURES_MAIN : FIGURES_FALLBACK;

node_modules/listr2/dist/utils/indent-string.d.ts

@@ -0,0 +1 @@
+export declare function indentString(string: string, count: number): string;

node_modules/listr2/dist/utils/indent-string.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.indentString = void 0;
+function indentString(string, count) {
+    return string.replace(/^(?!\s*$)/gm, ' '.repeat(count));
+}
+exports.indentString = indentString;

node_modules/listr2/dist/utils/is-unicode-supported.d.ts

@@ -0,0 +1 @@
+export declare function isUnicodeSupported(): boolean;

node_modules/listr2/dist/utils/is-unicode-supported.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isUnicodeSupported = void 0;
+function isUnicodeSupported() {
+    if (process.platform !== 'win32') {
+        return true;
+    }
+    return (Boolean(process.env.CI) || Boolean(process.env.WT_SESSION) || process.env.TERM_PROGRAM === 'vscode' || process.env.TERM === 'xterm-256color' || process.env.TERM === 'alacritty');
+}
+exports.isUnicodeSupported = isUnicodeSupported;

node_modules/listr2/dist/utils/logger.constants.d.ts

@@ -0,0 +1,12 @@
+/** Default loglevels for the logger */
+export declare enum LogLevels {
+    SILENT = "SILENT",
+    FAILED = "FAILED",
+    SKIPPED = "SKIPPED",
+    SUCCESS = "SUCCESS",
+    DATA = "DATA",
+    STARTED = "STARTED",
+    TITLE = "TITLE",
+    RETRY = "RETRY",
+    ROLLBACK = "ROLLBACK"
+}

node_modules/listr2/dist/utils/logger.constants.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LogLevels = void 0;
+/** Default loglevels for the logger */
+var LogLevels;
+(function (LogLevels) {
+    LogLevels["SILENT"] = "SILENT";
+    LogLevels["FAILED"] = "FAILED";
+    LogLevels["SKIPPED"] = "SKIPPED";
+    LogLevels["SUCCESS"] = "SUCCESS";
+    LogLevels["DATA"] = "DATA";
+    LogLevels["STARTED"] = "STARTED";
+    LogLevels["TITLE"] = "TITLE";
+    LogLevels["RETRY"] = "RETRY";
+    LogLevels["ROLLBACK"] = "ROLLBACK";
+})(LogLevels = exports.LogLevels || (exports.LogLevels = {}));

node_modules/listr2/dist/utils/logger.d.ts

@@ -0,0 +1,23 @@
+import { LogLevels } from './logger.constants';
+import { LoggerOptions } from './logger.interface';
+/**
+ * A internal logger for using in the verbose renderer mostly.
+ */
+export declare class Logger {
+    private options?;
+    constructor(options?: LoggerOptions);
+    fail(message: string): void;
+    skip(message: string): void;
+    success(message: string): void;
+    data(message: string): void;
+    start(message: string): void;
+    title(message: string): void;
+    retry(message: string): void;
+    rollback(message: string): void;
+    protected parseMessage(level: LogLevels, message: string): string;
+    protected logColoring({ level, message }: {
+        level: LogLevels;
+        message: string;
+    }): string;
+    private wrapInBrackets;
+}

node_modules/listr2/dist/utils/logger.interface.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Options for the logger
+ */
+export interface LoggerOptions {
+    useIcons: boolean;
+}

node_modules/listr2/dist/utils/logger.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

node_modules/listr2/dist/utils/logger.js

@@ -0,0 +1,159 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Logger = void 0;
+/* eslint-disable no-console */
+const figures_1 = require("./figures");
+const logger_constants_1 = require("./logger.constants");
+const colorette_1 = require("./colorette");
+/**
+ * A internal logger for using in the verbose renderer mostly.
+ */
+class Logger {
+    constructor(options) {
+        this.options = options;
+    }
+    fail(message) {
+        message = this.parseMessage(logger_constants_1.LogLevels.FAILED, message);
+        console.error(message);
+    }
+    skip(message) {
+        message = this.parseMessage(logger_constants_1.LogLevels.SKIPPED, message);
+        console.info(message);
+    }
+    success(message) {
+        message = this.parseMessage(logger_constants_1.LogLevels.SUCCESS, message);
+        console.log(message);
+    }
+    data(message) {
+        message = this.parseMessage(logger_constants_1.LogLevels.DATA, message);
+        console.info(message);
+    }
+    start(message) {
+        message = this.parseMessage(logger_constants_1.LogLevels.STARTED, message);
+        console.log(message);
+    }
+    title(message) {
+        message = this.parseMessage(logger_constants_1.LogLevels.TITLE, message);
+        console.info(message);
+    }
+    retry(message) {
+        message = this.parseMessage(logger_constants_1.LogLevels.RETRY, message);
+        console.warn(message);
+    }
+    rollback(message) {
+        message = this.parseMessage(logger_constants_1.LogLevels.ROLLBACK, message);
+        console.warn(message);
+    }
+    parseMessage(level, message) {
+        // parse multi line messages
+        let multiLineMessage;
+        try {
+            multiLineMessage = message.split('\n');
+        }
+        catch /* istanbul ignore next */ {
+            multiLineMessage = [message];
+        }
+        multiLineMessage = multiLineMessage.map((msg) => {
+            // format messages
+            return this.logColoring({
+                level,
+                message: msg
+            });
+        });
+        // join back multi line messages
+        message = multiLineMessage.join('\n');
+        return message;
+    }
+    logColoring({ level, message }) {
+        var _a, _b, _c, _d, _e, _f, _g, _h;
+        let icon;
+        // do the coloring
+        let coloring = (input) => {
+            return input;
+        };
+        switch (level) {
+            case logger_constants_1.LogLevels.FAILED:
+                /* istanbul ignore if */
+                if ((_a = this.options) === null || _a === void 0 ? void 0 : _a.useIcons) {
+                    coloring = colorette_1.default.red;
+                    icon = figures_1.figures.cross;
+                }
+                else {
+                    icon = this.wrapInBrackets(level);
+                }
+                break;
+            case logger_constants_1.LogLevels.SKIPPED:
+                /* istanbul ignore if */
+                if ((_b = this.options) === null || _b === void 0 ? void 0 : _b.useIcons) {
+                    coloring = colorette_1.default.yellow;
+                    icon = figures_1.figures.arrowDown;
+                }
+                else {
+                    icon = this.wrapInBrackets(level);
+                }
+                break;
+            case logger_constants_1.LogLevels.SUCCESS:
+                /* istanbul ignore if */
+                if ((_c = this.options) === null || _c === void 0 ? void 0 : _c.useIcons) {
+                    coloring = colorette_1.default.green;
+                    icon = figures_1.figures.tick;
+                }
+                else {
+                    icon = this.wrapInBrackets(level);
+                }
+                break;
+            case logger_constants_1.LogLevels.DATA:
+                /* istanbul ignore if */
+                if ((_d = this.options) === null || _d === void 0 ? void 0 : _d.useIcons) {
+                    icon = figures_1.figures.arrowRight;
+                }
+                else {
+                    icon = this.wrapInBrackets(level);
+                }
+                break;
+            case logger_constants_1.LogLevels.STARTED:
+                /* istanbul ignore if */
+                if ((_e = this.options) === null || _e === void 0 ? void 0 : _e.useIcons) {
+                    icon = figures_1.figures.pointer;
+                }
+                else {
+                    icon = this.wrapInBrackets(level);
+                }
+                break;
+            case logger_constants_1.LogLevels.TITLE:
+                /* istanbul ignore if */
+                if ((_f = this.options) === null || _f === void 0 ? void 0 : _f.useIcons) {
+                    icon = figures_1.figures.checkboxOn;
+                }
+                else {
+                    icon = this.wrapInBrackets(level);
+                }
+                break;
+            case logger_constants_1.LogLevels.RETRY:
+                /* istanbul ignore if */
+                if ((_g = this.options) === null || _g === void 0 ? void 0 : _g.useIcons) {
+                    coloring = colorette_1.default.yellow;
+                    icon = figures_1.figures.pointer;
+                }
+                else {
+                    icon = this.wrapInBrackets(level);
+                }
+                break;
+            case logger_constants_1.LogLevels.ROLLBACK:
+                /* istanbul ignore if */
+                if ((_h = this.options) === null || _h === void 0 ? void 0 : _h.useIcons) {
+                    coloring = colorette_1.default.red;
+                    icon = figures_1.figures.arrowLeft;
+                }
+                else {
+                    icon = this.wrapInBrackets(level);
+                }
+                break;
+        }
+        return coloring(`${icon} ${message}`);
+    }
+    wrapInBrackets(level) {
+        return `[${level}]`;
+    }
+}
+exports.Logger = Logger;

node_modules/listr2/dist/utils/parse-time.d.ts

@@ -0,0 +1 @@
+export declare function parseTaskTime(duration: number): string;

node_modules/listr2/dist/utils/parse-time.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseTaskTime = void 0;
+function parseTaskTime(duration) {
+    const seconds = Math.floor(duration / 1000);
+    const minutes = Math.floor(seconds / 60);
+    let parsedTime;
+    if (seconds === 0 && minutes === 0) {
+        parsedTime = `0.${Math.floor(duration / 100)}s`;
+    }
+    if (seconds > 0) {
+        parsedTime = `${seconds % 60}s`;
+    }
+    if (minutes > 0) {
+        parsedTime = `${minutes}m${parsedTime}`;
+    }
+    return parsedTime;
+}
+exports.parseTaskTime = parseTaskTime;

node_modules/listr2/dist/utils/prompt.d.ts

@@ -0,0 +1,12 @@
+import { PromptOptions, PromptSettings } from './prompt.interface';
+import { TaskWrapper } from '../lib/task-wrapper';
+/**
+ * Create a new prompt with Enquirer externally.
+ * This extends enquirer so you dont have to give a name to single prompts and such so it is also
+ * useful to use externally.
+ * @param this
+ * @param options
+ * @param settings
+ */
+export declare function createPrompt(this: any, options: PromptOptions | PromptOptions<true>[], settings?: PromptSettings): Promise<any>;
+export declare function destroyPrompt(this: TaskWrapper<any, any>, throwError?: boolean): void;

node_modules/listr2/dist/utils/prompt.interface.d.ts

@@ -0,0 +1,129 @@
+/// <reference types="node" />
+import * as Enquirer from 'enquirer';
+import { WriteStream } from 'fs';
+import { Writable } from 'stream';
+import { PromptError } from '../interfaces/listr-error.interface';
+/** Returns all the prompt options depending on the type selected. */
+export declare type PromptOptions<T extends boolean = false> = Unionize<{
+    [K in PromptTypes]-?: T extends true ? {
+        type: K;
+    } & PromptOptionsType<K> & {
+        name: string | (() => string);
+    } : {
+        type: K;
+    } & PromptOptionsType<K>;
+}> | ({
+    type: string;
+} & T extends true ? PromptOptionsType<string> & {
+    name: string | (() => string);
+} : PromptOptionsType<string>);
+export declare type Unionize<T extends Record<string, unknown>> = {
+    [P in keyof T]: T[P];
+}[keyof T];
+interface BasePromptOptions {
+    message: string | (() => string) | (() => Promise<string>);
+    initial?: boolean | number | number[] | string | (() => string) | (() => Promise<string>);
+    required?: boolean;
+    stdin?: NodeJS.ReadStream;
+    stdout?: NodeJS.WriteStream;
+    header?: string;
+    footer?: string;
+    skip?(value: any): boolean | Promise<boolean>;
+    format?(value: any): any | Promise<any>;
+    result?(value: any): any | Promise<any>;
+    validate?(value: any, state: any): boolean | Promise<boolean> | string | Promise<string> | Promise<string | boolean>;
+    onSubmit?(name: any, value: any, prompt: Enquirer.Prompt): boolean | Promise<boolean>;
+    onCancel?(name: any, value: any, prompt: Enquirer.Prompt): boolean | Promise<boolean>;
+}
+interface BasePromptOptionsWithName extends BasePromptOptions {
+    name: string | (() => string);
+}
+interface ArrayPromptOptions extends BasePromptOptions {
+    choices: string[] | BasePromptOptionsWithName[];
+    maxChoices?: number;
+    multiple?: boolean;
+    initial?: number | number[];
+    delay?: number;
+    separator?: boolean;
+    sort?: boolean;
+    linebreak?: boolean;
+    edgeLength?: number;
+    align?: 'left' | 'right';
+    scroll?: boolean;
+}
+interface BooleanPromptOptions extends BasePromptOptions {
+    initial?: boolean | (() => string) | (() => Promise<string>);
+}
+interface StringPromptOptions extends BasePromptOptions {
+    initial?: string;
+    multiline?: boolean;
+}
+interface ScalePromptOptions extends ArrayPromptOptions {
+    scale: StringPromptOptions[];
+    margin?: [number, number, number, number];
+}
+interface NumberPromptOptions extends BasePromptOptions {
+    min?: number;
+    max?: number;
+    delay?: number;
+    float?: boolean;
+    round?: boolean;
+    major?: number;
+    minor?: number;
+    initial?: number;
+}
+interface SnippetPromptOptions extends BasePromptOptions {
+    newline?: string;
+    fields: Partial<BasePromptOptionsWithName>[];
+    template: string;
+}
+interface SortPromptOptions extends BasePromptOptions {
+    hint?: string;
+    drag?: boolean;
+    numbered?: boolean;
+}
+interface SurveyPromptOptions extends ArrayPromptOptions {
+    scale: BasePromptOptionsWithName[];
+    margin: [number, number, number, number];
+}
+interface QuizPromptOptions extends ArrayPromptOptions {
+    correctChoice: number;
+}
+interface TogglePromptOptions extends BasePromptOptions {
+    enabled?: string;
+    disabled?: string;
+}
+export declare type PromptTypes = 'AutoComplete' | 'BasicAuth' | 'Confirm' | 'Editable' | 'Form' | 'Input' | 'Invisible' | 'List' | 'MultiSelect' | 'Numeral' | 'Password' | 'Quiz' | 'Scale' | 'Select' | 'Snippet' | 'Sort' | 'Survey' | 'Text' | 'Toggle';
+export declare type PromptOptionsType<T> = T extends keyof PromptOptionsMap ? PromptOptionsMap[T] : T extends string ? BasePromptOptions & Record<string, unknown> : any;
+export declare class PromptOptionsMap implements Record<PromptTypes, Record<string, any>> {
+    AutoComplete: ArrayPromptOptions;
+    BasicAuth: StringPromptOptions;
+    Confirm: BooleanPromptOptions;
+    Editable: ArrayPromptOptions;
+    Form: ArrayPromptOptions;
+    Input: StringPromptOptions;
+    Invisible: StringPromptOptions;
+    List: ArrayPromptOptions;
+    MultiSelect: ArrayPromptOptions;
+    Numeral: NumberPromptOptions;
+    Password: StringPromptOptions;
+    Quiz: QuizPromptOptions;
+    Scale: ScalePromptOptions;
+    Select: ArrayPromptOptions;
+    Snippet: SnippetPromptOptions;
+    Sort: SortPromptOptions;
+    Survey: SurveyPromptOptions;
+    Text: StringPromptOptions;
+    Toggle: TogglePromptOptions;
+}
+export interface PromptSettings {
+    error?: boolean;
+    cancelCallback?: (settings?: PromptSettings) => string | Error | PromptError | void;
+    stdout?: WriteStream | Writable;
+    enquirer?: Enquirer;
+}
+export interface PromptInstance extends Omit<BasePromptOptions, 'onCancel' | 'onSubmit'> {
+    submit(): void;
+    cancel(err?: string): void;
+}
+export {};

node_modules/listr2/dist/utils/prompt.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

node_modules/listr2/dist/utils/prompt.js

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.destroyPrompt = exports.createPrompt = void 0;
+const event_constants_1 = require("../constants/event.constants");
+const state_constants_1 = require("../constants/state.constants");
+const listr_error_interface_1 = require("../interfaces/listr-error.interface");
+const task_wrapper_1 = require("../lib/task-wrapper");
+/**
+ * Create a new prompt with Enquirer externally.
+ * This extends enquirer so you dont have to give a name to single prompts and such so it is also
+ * useful to use externally.
+ * @param this
+ * @param options
+ * @param settings
+ */
+async function createPrompt(options, settings) {
+    // override cancel callback
+    let cancelCallback;
+    /* istanbul ignore if */
+    if (settings === null || settings === void 0 ? void 0 : settings.cancelCallback) {
+        cancelCallback = settings.cancelCallback;
+    } /* istanbul ignore next */
+    else {
+        cancelCallback = defaultCancelCallback;
+    }
+    // assign default if there is single prompt
+    if (!Array.isArray(options)) {
+        options = [{ ...options, name: 'default' }];
+    } /* istanbul ignore next */
+    else if (options.length === 1) {
+        options = options.reduce((o, option) => {
+            return [...o, Object.assign(option, { name: 'default' })];
+        }, []);
+    }
+    // assign default enquirer options
+    options = options.reduce((o, option) => {
+        var _a;
+        return [
+            ...o,
+            Object.assign(option, {
+                // this is for outside calls, if it is not called from taskwrapper with bind
+                stdout: this instanceof task_wrapper_1.TaskWrapper ? (_a = settings === null || settings === void 0 ? void 0 : settings.stdout) !== null && _a !== void 0 ? _a : this.stdout() : process.stdout,
+                onCancel: cancelCallback.bind(this, settings)
+            })
+        ];
+    }, []);
+    let enquirer;
+    if (settings === null || settings === void 0 ? void 0 : settings.enquirer) {
+        // injected enquirer
+        enquirer = settings.enquirer;
+    }
+    else {
+        try {
+            enquirer = new (await Promise.resolve().then(() => require('enquirer')))();
+        } /* istanbul ignore next */
+        catch (e) {
+            this.task.prompt = new listr_error_interface_1.PromptError('Enquirer is a peer dependency that must be installed separately.');
+            throw new Error(e);
+        }
+    }
+    // i use this externally as well, this is a bandaid
+    if (this instanceof task_wrapper_1.TaskWrapper) {
+        // Capture the prompt instance so we can use it later
+        enquirer.on('prompt', (prompt) => this.task.prompt = prompt);
+        // Clear the prompt instance once it's submitted
+        // Can't use on cancel, since that might hold a PromptError object
+        enquirer.on('submit', () => this.task.prompt = undefined);
+        this.task.subscribe((event) => {
+            if (event.type === event_constants_1.ListrEventType.STATE && event.data === state_constants_1.ListrTaskState.SKIPPED) {
+                if (this.task.prompt && !(this.task.prompt instanceof listr_error_interface_1.PromptError)) {
+                    this.task.prompt.submit();
+                }
+            }
+        });
+    }
+    const response = (await enquirer.prompt(options));
+    // return default name if it is single prompt
+    if (options.length === 1) {
+        return response.default;
+    }
+    else {
+        return response;
+    }
+}
+exports.createPrompt = createPrompt;
+function destroyPrompt(throwError = false) {
+    if (!this.task.prompt || this.task.prompt instanceof listr_error_interface_1.PromptError) {
+        // If there's no prompt, can't cancel
+        return;
+    }
+    if (throwError) {
+        this.task.prompt.cancel();
+    }
+    else {
+        this.task.prompt.submit();
+    }
+}
+exports.destroyPrompt = destroyPrompt;
+function defaultCancelCallback(settings) {
+    const errorMsg = 'Cancelled prompt.';
+    if (this instanceof task_wrapper_1.TaskWrapper) {
+        this.task.prompt = new listr_error_interface_1.PromptError(errorMsg);
+    } /* istanbul ignore next */
+    else if ((settings === null || settings === void 0 ? void 0 : settings.error) !== false) {
+        throw new Error(errorMsg);
+    } /* istanbul ignore next */
+    else {
+        return errorMsg;
+    }
+}

node_modules/listr2/dist/utils/renderer.d.ts

@@ -0,0 +1,3 @@
+import { ListrOptions } from '../interfaces/listr.interface';
+import { SupportedRenderer, ListrRendererValue } from '../interfaces/renderer.interface';
+export declare function getRenderer(renderer: ListrRendererValue, fallbackRenderer?: ListrRendererValue, fallbackCondition?: ListrOptions['rendererFallback'], silentCondition?: ListrOptions['rendererSilent']): SupportedRenderer;

node_modules/listr2/dist/utils/renderer.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRenderer = void 0;
+const default_renderer_1 = require("../renderer/default.renderer");
+const silent_renderer_1 = require("../renderer/silent.renderer");
+const simple_renderer_1 = require("../renderer/simple.renderer");
+const verbose_renderer_1 = require("../renderer/verbose.renderer");
+const assert_1 = require("./assert");
+const renderers = {
+    default: default_renderer_1.DefaultRenderer,
+    simple: simple_renderer_1.SimpleRenderer,
+    verbose: verbose_renderer_1.VerboseRenderer,
+    silent: silent_renderer_1.SilentRenderer
+};
+function isRendererSupported(renderer) {
+    return process.stdout.isTTY === true || renderer.nonTTY === true;
+}
+function getRendererClass(renderer) {
+    if (typeof renderer === 'string') {
+        return renderers[renderer] || renderers.default;
+    }
+    return typeof renderer === 'function' ? renderer : renderers.default;
+}
+function getRenderer(renderer, fallbackRenderer, fallbackCondition, silentCondition) {
+    let returnValue;
+    let ret = getRendererClass(renderer);
+    returnValue = { renderer: ret, nonTTY: false };
+    const evaluateSilent = assert_1.assertFunctionOrSelf(silentCondition);
+    const evaluateFallback = assert_1.assertFunctionOrSelf(fallbackCondition);
+    if (evaluateSilent) {
+        ret = getRendererClass('silent');
+        returnValue = { renderer: ret, nonTTY: true };
+    }
+    else if (!isRendererSupported(ret) || evaluateFallback) {
+        ret = getRendererClass(fallbackRenderer);
+        returnValue = { renderer: ret, nonTTY: true };
+    }
+    return returnValue;
+}
+exports.getRenderer = getRenderer;

node_modules/listr2/dist/utils/uuid.d.ts

@@ -0,0 +1,2 @@
+/** Generate a basic uuid with no requirement of being unbelievable unique. */
+export declare function generateUUID(): string;

node_modules/listr2/dist/utils/uuid.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateUUID = void 0;
+/** Generate a basic uuid with no requirement of being unbelievable unique. */
+function generateUUID() {
+    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {
+        const r = Math.random() * 16 || 0;
+        const v = c === 'x' ? r : r && 0x3 || 0x8;
+        return v.toString(16);
+    });
+}
+exports.generateUUID = generateUUID;