taskninja 1.1.3 → 1.1.4

package/src/node_modules/@inquirer/core/dist/lib/create-prompt.js

@@ -0,0 +1,117 @@
+import * as readline from 'node:readline';
+import { AsyncResource } from 'node:async_hooks';
+import MuteStream from 'mute-stream';
+import { onExit as onSignalExit } from 'signal-exit';
+import ScreenManager from "./screen-manager.js";
+import { PromisePolyfill } from "./promise-polyfill.js";
+import { withHooks, effectScheduler } from "./hook-engine.js";
+import { AbortPromptError, CancelPromptError, ExitPromptError } from "./errors.js";
+function getCallSites() {
+    // eslint-disable-next-line @typescript-eslint/unbound-method
+    const _prepareStackTrace = Error.prepareStackTrace;
+    let result = [];
+    try {
+        Error.prepareStackTrace = (_, callSites) => {
+            const callSitesWithoutCurrent = callSites.slice(1);
+            result = callSitesWithoutCurrent;
+            return callSitesWithoutCurrent;
+        };
+        // oxlint-disable-next-line no-unused-expressions
+        new Error().stack;
+    }
+    catch {
+        // An error will occur if the Node flag --frozen-intrinsics is used.
+        // https://nodejs.org/api/cli.html#--frozen-intrinsics
+        return result;
+    }
+    Error.prepareStackTrace = _prepareStackTrace;
+    return result;
+}
+export function createPrompt(view) {
+    const callSites = getCallSites();
+    const prompt = (config, context = {}) => {
+        // Default `input` to stdin
+        const { input = process.stdin, signal } = context;
+        const cleanups = new Set();
+        // Add mute capabilities to the output
+        const output = new MuteStream();
+        output.pipe(context.output ?? process.stdout);
+        const rl = readline.createInterface({
+            terminal: true,
+            input,
+            output,
+        });
+        const screen = new ScreenManager(rl);
+        const { promise, resolve, reject } = PromisePolyfill.withResolver();
+        const cancel = () => reject(new CancelPromptError());
+        if (signal) {
+            const abort = () => reject(new AbortPromptError({ cause: signal.reason }));
+            if (signal.aborted) {
+                abort();
+                return Object.assign(promise, { cancel });
+            }
+            signal.addEventListener('abort', abort);
+            cleanups.add(() => signal.removeEventListener('abort', abort));
+        }
+        cleanups.add(onSignalExit((code, signal) => {
+            reject(new ExitPromptError(`User force closed the prompt with ${code} ${signal}`));
+        }));
+        // SIGINT must be explicitly handled by the prompt so the ExitPromptError can be handled.
+        // Otherwise, the prompt will stop and in some scenarios never resolve.
+        // Ref issue #1741
+        const sigint = () => reject(new ExitPromptError(`User force closed the prompt with SIGINT`));
+        rl.on('SIGINT', sigint);
+        cleanups.add(() => rl.removeListener('SIGINT', sigint));
+        // Re-renders only happen when the state change; but the readline cursor could change position
+        // and that also requires a re-render (and a manual one because we mute the streams).
+        // We set the listener after the initial workLoop to avoid a double render if render triggered
+        // by a state change sets the cursor to the right position.
+        const checkCursorPos = () => screen.checkCursorPos();
+        rl.input.on('keypress', checkCursorPos);
+        cleanups.add(() => rl.input.removeListener('keypress', checkCursorPos));
+        return withHooks(rl, (cycle) => {
+            // The close event triggers immediately when the user press ctrl+c. SignalExit on the other hand
+            // triggers after the process is done (which happens after timeouts are done triggering.)
+            // We triggers the hooks cleanup phase on rl `close` so active timeouts can be cleared.
+            const hooksCleanup = AsyncResource.bind(() => effectScheduler.clearAll());
+            rl.on('close', hooksCleanup);
+            cleanups.add(() => rl.removeListener('close', hooksCleanup));
+            cycle(() => {
+                try {
+                    const nextView = view(config, (value) => {
+                        setImmediate(() => resolve(value));
+                    });
+                    // Typescript won't allow this, but not all users rely on typescript.
+                    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+                    if (nextView === undefined) {
+                        const callerFilename = callSites[1]?.getFileName();
+                        throw new Error(`Prompt functions must return a string.\n    at ${callerFilename}`);
+                    }
+                    const [content, bottomContent] = typeof nextView === 'string' ? [nextView] : nextView;
+                    screen.render(content, bottomContent);
+                    effectScheduler.run();
+                }
+                catch (error) {
+                    reject(error);
+                }
+            });
+            return Object.assign(promise
+                .then((answer) => {
+                effectScheduler.clearAll();
+                return answer;
+            }, (error) => {
+                effectScheduler.clearAll();
+                throw error;
+            })
+                // Wait for the promise to settle, then cleanup.
+                .finally(() => {
+                cleanups.forEach((cleanup) => cleanup());
+                screen.done({ clearContent: Boolean(context.clearPromptOnDone) });
+                output.end();
+            })
+                // Once cleanup is done, let the expose promise resolve/reject to the internal one.
+                .then(() => promise), { cancel });
+        });
+    };
+    return prompt;
+}

package/src/node_modules/@inquirer/core/dist/lib/errors.d.ts

@@ -0,0 +1,20 @@
+export declare class AbortPromptError extends Error {
+    name: string;
+    message: string;
+    constructor(options?: {
+        cause?: unknown;
+    });
+}
+export declare class CancelPromptError extends Error {
+    name: string;
+    message: string;
+}
+export declare class ExitPromptError extends Error {
+    name: string;
+}
+export declare class HookError extends Error {
+    name: string;
+}
+export declare class ValidationError extends Error {
+    name: string;
+}

package/src/node_modules/@inquirer/core/dist/lib/errors.js

@@ -0,0 +1,21 @@
+export class AbortPromptError extends Error {
+    name = 'AbortPromptError';
+    message = 'Prompt was aborted';
+    constructor(options) {
+        super();
+        this.cause = options?.cause;
+    }
+}
+export class CancelPromptError extends Error {
+    name = 'CancelPromptError';
+    message = 'Prompt was canceled';
+}
+export class ExitPromptError extends Error {
+    name = 'ExitPromptError';
+}
+export class HookError extends Error {
+    name = 'HookError';
+}
+export class ValidationError extends Error {
+    name = 'ValidationError';
+}

package/src/node_modules/@inquirer/core/dist/lib/hook-engine.d.ts

@@ -0,0 +1,23 @@
+import type { InquirerReadline } from '@inquirer/type';
+export declare function withHooks<T>(rl: InquirerReadline, cb: (cycle: (render: () => void) => void) => T): T;
+export declare function readline(): InquirerReadline;
+export declare function withUpdates<Args extends unknown[], R>(fn: (...args: Args) => R): (...args: Args) => R;
+type SetPointer<Value> = {
+    get(): Value;
+    set(value: Value): void;
+    initialized: true;
+};
+type UnsetPointer<Value> = {
+    get(): void;
+    set(value: Value): void;
+    initialized: false;
+};
+type Pointer<Value> = SetPointer<Value> | UnsetPointer<Value>;
+export declare function withPointer<Value, ReturnValue>(cb: (pointer: Pointer<Value>) => ReturnValue): ReturnValue;
+export declare function handleChange(): void;
+export declare const effectScheduler: {
+    queue(cb: (readline: InquirerReadline) => void | (() => void)): void;
+    run(): void;
+    clearAll(): void;
+};
+export {};

package/src/node_modules/@inquirer/core/dist/lib/hook-engine.js

@@ -0,0 +1,110 @@
+/* eslint @typescript-eslint/no-explicit-any: ["off"] */
+import { AsyncLocalStorage, AsyncResource } from 'node:async_hooks';
+import { HookError, ValidationError } from "./errors.js";
+const hookStorage = new AsyncLocalStorage();
+function createStore(rl) {
+    const store = {
+        rl,
+        hooks: [],
+        hooksCleanup: [],
+        hooksEffect: [],
+        index: 0,
+        handleChange() { },
+    };
+    return store;
+}
+// Run callback in with the hook engine setup.
+export function withHooks(rl, cb) {
+    const store = createStore(rl);
+    return hookStorage.run(store, () => {
+        function cycle(render) {
+            store.handleChange = () => {
+                store.index = 0;
+                render();
+            };
+            store.handleChange();
+        }
+        return cb(cycle);
+    });
+}
+// Safe getStore utility that'll return the store or throw if undefined.
+function getStore() {
+    const store = hookStorage.getStore();
+    if (!store) {
+        throw new HookError('[Inquirer] Hook functions can only be called from within a prompt');
+    }
+    return store;
+}
+export function readline() {
+    return getStore().rl;
+}
+// Merge state updates happening within the callback function to avoid multiple renders.
+export function withUpdates(fn) {
+    const wrapped = (...args) => {
+        const store = getStore();
+        let shouldUpdate = false;
+        const oldHandleChange = store.handleChange;
+        store.handleChange = () => {
+            shouldUpdate = true;
+        };
+        const returnValue = fn(...args);
+        if (shouldUpdate) {
+            oldHandleChange();
+        }
+        store.handleChange = oldHandleChange;
+        return returnValue;
+    };
+    return AsyncResource.bind(wrapped);
+}
+export function withPointer(cb) {
+    const store = getStore();
+    const { index } = store;
+    const pointer = {
+        get() {
+            return store.hooks[index];
+        },
+        set(value) {
+            store.hooks[index] = value;
+        },
+        initialized: index in store.hooks,
+    };
+    const returnValue = cb(pointer);
+    store.index++;
+    return returnValue;
+}
+export function handleChange() {
+    getStore().handleChange();
+}
+export const effectScheduler = {
+    queue(cb) {
+        const store = getStore();
+        const { index } = store;
+        store.hooksEffect.push(() => {
+            store.hooksCleanup[index]?.();
+            const cleanFn = cb(readline());
+            if (cleanFn != null && typeof cleanFn !== 'function') {
+                throw new ValidationError('useEffect return value must be a cleanup function or nothing.');
+            }
+            store.hooksCleanup[index] = cleanFn;
+        });
+    },
+    run() {
+        const store = getStore();
+        withUpdates(() => {
+            store.hooksEffect.forEach((effect) => {
+                effect();
+            });
+            // Warning: Clean the hooks before exiting the `withUpdates` block.
+            // Failure to do so means an updates would hit the same effects again.
+            store.hooksEffect.length = 0;
+        })();
+    },
+    clearAll() {
+        const store = getStore();
+        store.hooksCleanup.forEach((cleanFn) => {
+            cleanFn?.();
+        });
+        store.hooksEffect.length = 0;
+        store.hooksCleanup.length = 0;
+    },
+};

package/src/node_modules/@inquirer/core/dist/lib/key.d.ts

@@ -0,0 +1,14 @@
+export type KeypressEvent = {
+    name: string;
+    ctrl: boolean;
+    shift: boolean;
+};
+export type Keybinding = 'emacs' | 'vim';
+export declare const isUpKey: (key: KeypressEvent, keybindings?: ReadonlyArray<Keybinding>) => boolean;
+export declare const isDownKey: (key: KeypressEvent, keybindings?: ReadonlyArray<Keybinding>) => boolean;
+export declare const isSpaceKey: (key: KeypressEvent) => boolean;
+export declare const isBackspaceKey: (key: KeypressEvent) => boolean;
+export declare const isTabKey: (key: KeypressEvent) => boolean;
+export declare const isNumberKey: (key: KeypressEvent) => boolean;
+export declare const isEnterKey: (key: KeypressEvent) => boolean;
+export declare const isShiftKey: (key: KeypressEvent) => boolean;

package/src/node_modules/@inquirer/core/dist/lib/key.js

@@ -0,0 +1,20 @@
+export const isUpKey = (key, keybindings = []) => 
+// The up key
+key.name === 'up' ||
+    // Vim keybinding: hjkl keys map to left/down/up/right
+    (keybindings.includes('vim') && key.name === 'k') ||
+    // Emacs keybinding: Ctrl+P means "previous" in Emacs navigation conventions
+    (keybindings.includes('emacs') && key.ctrl && key.name === 'p');
+export const isDownKey = (key, keybindings = []) => 
+// The down key
+key.name === 'down' ||
+    // Vim keybinding: hjkl keys map to left/down/up/right
+    (keybindings.includes('vim') && key.name === 'j') ||
+    // Emacs keybinding: Ctrl+N means "next" in Emacs navigation conventions
+    (keybindings.includes('emacs') && key.ctrl && key.name === 'n');
+export const isSpaceKey = (key) => key.name === 'space';
+export const isBackspaceKey = (key) => key.name === 'backspace';
+export const isTabKey = (key) => key.name === 'tab';
+export const isNumberKey = (key) => '1234567890'.includes(key.name);
+export const isEnterKey = (key) => key.name === 'enter' || key.name === 'return';
+export const isShiftKey = (key) => key.shift;

package/src/node_modules/@inquirer/core/dist/lib/make-theme.d.ts

@@ -0,0 +1,3 @@
+import type { Prettify, PartialDeep } from '@inquirer/type';
+import { type Theme } from './theme';
+export declare function makeTheme<SpecificTheme extends object>(...themes: ReadonlyArray<undefined | PartialDeep<Theme<SpecificTheme>>>): Prettify<Theme<SpecificTheme>>;

package/src/node_modules/@inquirer/core/dist/lib/make-theme.js

@@ -0,0 +1,30 @@
+import { defaultTheme } from "./theme.js";
+function isPlainObject(value) {
+    if (typeof value !== 'object' || value === null)
+        return false;
+    let proto = value;
+    while (Object.getPrototypeOf(proto) !== null) {
+        proto = Object.getPrototypeOf(proto);
+    }
+    return Object.getPrototypeOf(value) === proto;
+}
+function deepMerge(...objects) {
+    const output = {};
+    for (const obj of objects) {
+        for (const [key, value] of Object.entries(obj)) {
+            const prevValue = output[key];
+            output[key] =
+                isPlainObject(prevValue) && isPlainObject(value)
+                    ? deepMerge(prevValue, value)
+                    : value;
+        }
+    }
+    return output;
+}
+export function makeTheme(...themes) {
+    const themesToMerge = [
+        defaultTheme,
+        ...themes.filter((theme) => theme != null),
+    ];
+    return deepMerge(...themesToMerge);
+}

package/src/node_modules/@inquirer/core/dist/lib/pagination/use-pagination.d.ts

@@ -0,0 +1,16 @@
+import type { Prettify } from '@inquirer/type';
+export declare function usePagination<T>({ items, active, renderItem, pageSize, loop, }: {
+    items: ReadonlyArray<T>;
+    /** The index of the active item. */
+    active: number;
+    /** Renders an item as part of a page. */
+    renderItem: (layout: Prettify<{
+        item: T;
+        index: number;
+        isActive: boolean;
+    }>) => string;
+    /** The size of the page. */
+    pageSize: number;
+    /** Allows creating an infinitely looping list. `true` if unspecified. */
+    loop?: boolean;
+}): string;

package/src/node_modules/@inquirer/core/dist/lib/pagination/use-pagination.js

@@ -0,0 +1,121 @@
+import { useRef } from "../use-ref.js";
+import { readlineWidth, breakLines } from "../utils.js";
+function usePointerPosition({ active, renderedItems, pageSize, loop, }) {
+    const state = useRef({
+        lastPointer: active,
+        lastActive: undefined,
+    });
+    const { lastPointer, lastActive } = state.current;
+    const middle = Math.floor(pageSize / 2);
+    const renderedLength = renderedItems.reduce((acc, item) => acc + item.length, 0);
+    const defaultPointerPosition = renderedItems
+        .slice(0, active)
+        .reduce((acc, item) => acc + item.length, 0);
+    let pointer = defaultPointerPosition;
+    if (renderedLength > pageSize) {
+        if (loop) {
+            /**
+             * Creates the next position for the pointer considering an infinitely
+             * looping list of items to be rendered on the page.
+             *
+             * The goal is to progressively move the cursor to the middle position as the user move down, and then keep
+             * the cursor there. When the user move up, maintain the cursor position.
+             */
+            // By default, keep the cursor position as-is.
+            pointer = lastPointer;
+            if (
+            // First render, skip this logic.
+            lastActive != null &&
+                // Only move the pointer down when the user moves down.
+                lastActive < active &&
+                // Check user didn't move up across page boundary.
+                active - lastActive < pageSize) {
+                pointer = Math.min(
+                // Furthest allowed position for the pointer is the middle of the list
+                middle, Math.abs(active - lastActive) === 1
+                    ? Math.min(
+                    // Move the pointer at most the height of the last active item.
+                    lastPointer + (renderedItems[lastActive]?.length ?? 0), 
+                    // If the user moved by one item, move the pointer to the natural position of the active item as
+                    // long as it doesn't move the cursor up.
+                    Math.max(defaultPointerPosition, lastPointer))
+                    : // Otherwise, move the pointer down by the difference between the active and last active item.
+                        lastPointer + active - lastActive);
+            }
+        }
+        else {
+            /**
+             * Creates the next position for the pointer considering a finite list of
+             * items to be rendered on a page.
+             *
+             * The goal is to keep the pointer in the middle of the page whenever possible, until
+             * we reach the bounds of the list (top or bottom). In which case, the cursor moves progressively
+             * to the bottom or top of the list.
+             */
+            const spaceUnderActive = renderedItems
+                .slice(active)
+                .reduce((acc, item) => acc + item.length, 0);
+            pointer =
+                spaceUnderActive < pageSize - middle
+                    ? // If the active item is near the end of the list, progressively move the cursor towards the end.
+                        pageSize - spaceUnderActive
+                    : // Otherwise, progressively move the pointer to the middle of the list.
+                        Math.min(defaultPointerPosition, middle);
+        }
+    }
+    // Save state for the next render
+    state.current.lastPointer = pointer;
+    state.current.lastActive = active;
+    return pointer;
+}
+export function usePagination({ items, active, renderItem, pageSize, loop = true, }) {
+    const width = readlineWidth();
+    const bound = (num) => ((num % items.length) + items.length) % items.length;
+    const renderedItems = items.map((item, index) => {
+        if (item == null)
+            return [];
+        return breakLines(renderItem({ item, index, isActive: index === active }), width).split('\n');
+    });
+    const renderedLength = renderedItems.reduce((acc, item) => acc + item.length, 0);
+    const renderItemAtIndex = (index) => renderedItems[index] ?? [];
+    const pointer = usePointerPosition({ active, renderedItems, pageSize, loop });
+    // Render the active item to decide the position.
+    // If the active item fits under the pointer, we render it there.
+    // Otherwise, we need to render it to fit at the bottom of the page; moving the pointer up.
+    const activeItem = renderItemAtIndex(active).slice(0, pageSize);
+    const activeItemPosition = pointer + activeItem.length <= pageSize ? pointer : pageSize - activeItem.length;
+    // Create an array of lines for the page, and add the lines of the active item into the page
+    const pageBuffer = Array.from({ length: pageSize });
+    pageBuffer.splice(activeItemPosition, activeItem.length, ...activeItem);
+    // Store to prevent rendering the same item twice
+    const itemVisited = new Set([active]);
+    // Fill the page under the active item
+    let bufferPointer = activeItemPosition + activeItem.length;
+    let itemPointer = bound(active + 1);
+    while (bufferPointer < pageSize &&
+        !itemVisited.has(itemPointer) &&
+        (loop && renderedLength > pageSize ? itemPointer !== active : itemPointer > active)) {
+        const lines = renderItemAtIndex(itemPointer);
+        const linesToAdd = lines.slice(0, pageSize - bufferPointer);
+        pageBuffer.splice(bufferPointer, linesToAdd.length, ...linesToAdd);
+        // Move pointers for next iteration
+        itemVisited.add(itemPointer);
+        bufferPointer += linesToAdd.length;
+        itemPointer = bound(itemPointer + 1);
+    }
+    // Fill the page over the active item
+    bufferPointer = activeItemPosition - 1;
+    itemPointer = bound(active - 1);
+    while (bufferPointer >= 0 &&
+        !itemVisited.has(itemPointer) &&
+        (loop && renderedLength > pageSize ? itemPointer !== active : itemPointer < active)) {
+        const lines = renderItemAtIndex(itemPointer);
+        const linesToAdd = lines.slice(Math.max(0, lines.length - bufferPointer - 1));
+        pageBuffer.splice(bufferPointer - linesToAdd.length + 1, linesToAdd.length, ...linesToAdd);
+        // Move pointers for next iteration
+        itemVisited.add(itemPointer);
+        bufferPointer -= linesToAdd.length;
+        itemPointer = bound(itemPointer - 1);
+    }
+    return pageBuffer.filter((line) => typeof line === 'string').join('\n');
+}

package/src/node_modules/@inquirer/core/dist/lib/promise-polyfill.d.ts

@@ -0,0 +1,7 @@
+export declare class PromisePolyfill<T> extends Promise<T> {
+    static withResolver<T>(): {
+        promise: Promise<T>;
+        resolve: (value: T) => void;
+        reject: (error: unknown) => void;
+    };
+}

package/src/node_modules/@inquirer/core/dist/lib/promise-polyfill.js

@@ -0,0 +1,14 @@
+// TODO: Remove this class once Node 22 becomes the minimum supported version.
+export class PromisePolyfill extends Promise {
+    // Available starting from Node 22
+    // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/withResolvers
+    static withResolver() {
+        let resolve;
+        let reject;
+        const promise = new Promise((res, rej) => {
+            resolve = res;
+            reject = rej;
+        });
+        return { promise, resolve: resolve, reject: reject };
+    }
+}

package/src/node_modules/@inquirer/core/dist/lib/screen-manager.d.ts

@@ -0,0 +1,14 @@
+import type { InquirerReadline } from '@inquirer/type';
+export default class ScreenManager {
+    private height;
+    private extraLinesUnderPrompt;
+    private cursorPos;
+    private readonly rl;
+    constructor(rl: InquirerReadline);
+    write(content: string): void;
+    render(content: string, bottomContent?: string): void;
+    checkCursorPos(): void;
+    done({ clearContent }: {
+        clearContent: boolean;
+    }): void;
+}

package/src/node_modules/@inquirer/core/dist/lib/screen-manager.js

@@ -0,0 +1,79 @@
+import { stripVTControlCharacters } from 'node:util';
+import { breakLines, readlineWidth } from "./utils.js";
+import { cursorDown, cursorUp, cursorTo, cursorShow, eraseLines } from '@inquirer/ansi';
+const height = (content) => content.split('\n').length;
+const lastLine = (content) => content.split('\n').pop() ?? '';
+export default class ScreenManager {
+    // These variables are keeping information to allow correct prompt re-rendering
+    height = 0;
+    extraLinesUnderPrompt = 0;
+    cursorPos;
+    rl;
+    constructor(rl) {
+        this.rl = rl;
+        this.cursorPos = rl.getCursorPos();
+    }
+    write(content) {
+        this.rl.output.unmute();
+        this.rl.output.write(content);
+        this.rl.output.mute();
+    }
+    render(content, bottomContent = '') {
+        // Write message to screen and setPrompt to control backspace
+        const promptLine = lastLine(content);
+        const rawPromptLine = stripVTControlCharacters(promptLine);
+        // Remove the rl.line from our prompt. We can't rely on the content of
+        // rl.line (mainly because of the password prompt), so just rely on it's
+        // length.
+        let prompt = rawPromptLine;
+        if (this.rl.line.length > 0) {
+            prompt = prompt.slice(0, -this.rl.line.length);
+        }
+        this.rl.setPrompt(prompt);
+        // SetPrompt will change cursor position, now we can get correct value
+        this.cursorPos = this.rl.getCursorPos();
+        const width = readlineWidth();
+        content = breakLines(content, width);
+        bottomContent = breakLines(bottomContent, width);
+        // Manually insert an extra line if we're at the end of the line.
+        // This prevent the cursor from appearing at the beginning of the
+        // current line.
+        if (rawPromptLine.length % width === 0) {
+            content += '\n';
+        }
+        let output = content + (bottomContent ? '\n' + bottomContent : '');
+        /**
+         * Re-adjust the cursor at the correct position.
+         */
+        // We need to consider parts of the prompt under the cursor as part of the bottom
+        // content in order to correctly cleanup and re-render.
+        const promptLineUpDiff = Math.floor(rawPromptLine.length / width) - this.cursorPos.rows;
+        const bottomContentHeight = promptLineUpDiff + (bottomContent ? height(bottomContent) : 0);
+        // Return cursor to the input position (on top of the bottomContent)
+        if (bottomContentHeight > 0)
+            output += cursorUp(bottomContentHeight);
+        // Return cursor to the initial left offset.
+        output += cursorTo(this.cursorPos.cols);
+        /**
+         * Render and store state for future re-rendering
+         */
+        this.write(cursorDown(this.extraLinesUnderPrompt) + eraseLines(this.height) + output);
+        this.extraLinesUnderPrompt = bottomContentHeight;
+        this.height = height(output);
+    }
+    checkCursorPos() {
+        const cursorPos = this.rl.getCursorPos();
+        if (cursorPos.cols !== this.cursorPos.cols) {
+            this.write(cursorTo(cursorPos.cols));
+            this.cursorPos = cursorPos;
+        }
+    }
+    done({ clearContent }) {
+        this.rl.setPrompt('');
+        let output = cursorDown(this.extraLinesUnderPrompt);
+        output += clearContent ? eraseLines(this.height) : '\n';
+        output += cursorShow;
+        this.write(output);
+        this.rl.close();
+    }
+}