create-openclaw-bot 5.1.15 → 5.2.1

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

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeTheme = void 0;
+const theme_mjs_1 = require('./theme.js');
+function makeTheme(...themes) {
+    return Object.assign({}, theme_mjs_1.defaultTheme, ...themes, {
+        style: Object.assign({}, theme_mjs_1.defaultTheme.style, ...themes.map((theme) => theme === null || theme === void 0 ? void 0 : theme.style)),
+    });
+}
+exports.makeTheme = makeTheme;

package/node_modules/@inquirer/core/dist/cjs/lib/pagination/lines.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lines = void 0;
+const utils_mjs_1 = require('../utils.js');
+function split(content, width) {
+    return (0, utils_mjs_1.breakLines)(content, width).split('\n');
+}
+/**
+ * Rotates an array of items by an integer number of positions.
+ * @param {number} count The number of positions to rotate by
+ * @param {T[]} items The items to rotate
+ */
+function rotate(count, items) {
+    const max = items.length;
+    const offset = ((count % max) + max) % max;
+    return items.slice(offset).concat(items.slice(0, offset));
+}
+/**
+ * Renders a page of items as lines that fit within the given width ensuring
+ * that the number of lines is not greater than the page size, and the active
+ * item renders at the provided position, while prioritizing that as many lines
+ * of the active item get rendered as possible.
+ */
+function lines({ items, width, renderItem, active, position: requested, pageSize, }) {
+    const layouts = items.map((item, index) => ({
+        item,
+        index,
+        isActive: index === active,
+    }));
+    const layoutsInPage = rotate(active - requested, layouts).slice(0, pageSize);
+    const renderItemAt = (index) => split(renderItem(layoutsInPage[index]), width);
+    // Create a blank array of lines for the page
+    const pageBuffer = new Array(pageSize);
+    // Render the active item to decide the position
+    const activeItem = renderItemAt(requested).slice(0, pageSize);
+    const position = requested + activeItem.length <= pageSize ? requested : pageSize - activeItem.length;
+    // Add the lines of the active item into the page
+    pageBuffer.splice(position, activeItem.length, ...activeItem);
+    // Fill the page under the active item
+    let bufferPointer = position + activeItem.length;
+    let layoutPointer = requested + 1;
+    while (bufferPointer < pageSize && layoutPointer < layoutsInPage.length) {
+        for (const line of renderItemAt(layoutPointer)) {
+            pageBuffer[bufferPointer++] = line;
+            if (bufferPointer >= pageSize)
+                break;
+        }
+        layoutPointer++;
+    }
+    // Fill the page over the active item
+    bufferPointer = position - 1;
+    layoutPointer = requested - 1;
+    while (bufferPointer >= 0 && layoutPointer >= 0) {
+        for (const line of renderItemAt(layoutPointer).reverse()) {
+            pageBuffer[bufferPointer--] = line;
+            if (bufferPointer < 0)
+                break;
+        }
+        layoutPointer--;
+    }
+    return pageBuffer.filter((line) => typeof line === 'string');
+}
+exports.lines = lines;

package/node_modules/@inquirer/core/dist/cjs/lib/pagination/position.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.infinite = exports.finite = void 0;
+/**
+ * Creates the next position for the active item considering a finite list of
+ * items to be rendered on a page.
+ */
+function finite({ active, pageSize, total, }) {
+    const middle = Math.floor(pageSize / 2);
+    if (total <= pageSize || active < middle)
+        return active;
+    if (active >= total - middle)
+        return active + pageSize - total;
+    return middle;
+}
+exports.finite = finite;
+/**
+ * Creates the next position for the active item considering an infinitely
+ * looping list of items to be rendered on the page.
+ */
+function infinite({ active, lastActive, total, pageSize, pointer, }) {
+    if (total <= pageSize)
+        return active;
+    // Move the position only when the user moves down, and when the
+    // navigation fits within a single page
+    if (lastActive < active && active - lastActive < pageSize) {
+        // Limit it to the middle of the list
+        return Math.min(Math.floor(pageSize / 2), pointer + active - lastActive);
+    }
+    return pointer;
+}
+exports.infinite = infinite;

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

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.usePagination = void 0;
+const use_ref_mjs_1 = require('../use-ref.js');
+const utils_mjs_1 = require('../utils.js');
+const make_theme_mjs_1 = require('../make-theme.js');
+const lines_mjs_1 = require('./lines.js');
+const position_mjs_1 = require('./position.js');
+function usePagination({ items, active, renderItem, pageSize, loop = true, theme: defaultTheme, }) {
+    const state = (0, use_ref_mjs_1.useRef)({ position: 0, lastActive: 0 });
+    const theme = (0, make_theme_mjs_1.makeTheme)(defaultTheme);
+    const position = loop
+        ? (0, position_mjs_1.infinite)({
+            active,
+            lastActive: state.current.lastActive,
+            total: items.length,
+            pageSize,
+            pointer: state.current.position,
+        })
+        : (0, position_mjs_1.finite)({
+            active,
+            total: items.length,
+            pageSize,
+        });
+    state.current.position = position;
+    state.current.lastActive = active;
+    const visibleLines = (0, lines_mjs_1.lines)({
+        items,
+        width: (0, utils_mjs_1.readlineWidth)(),
+        renderItem,
+        active,
+        position,
+        pageSize,
+    }).join('\n');
+    if (items.length > pageSize) {
+        return `${visibleLines}\n${theme.style.help('(Use arrow keys to reveal more choices)')}`;
+    }
+    return visibleLines;
+}
+exports.usePagination = usePagination;

package/node_modules/@inquirer/core/dist/cjs/lib/read-line.type.js

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

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

@@ -0,0 +1,128 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const strip_ansi_1 = __importDefault(require("strip-ansi"));
+const ansi_escapes_1 = __importDefault(require("ansi-escapes"));
+const utils_mjs_1 = require('./utils.js');
+const height = (content) => content.split('\n').length;
+const lastLine = (content) => { var _a; return (_a = content.split('\n').pop()) !== null && _a !== void 0 ? _a : ''; };
+class ScreenManager {
+    constructor(rl) {
+        Object.defineProperty(this, "rl", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: rl
+        });
+        // These variables are keeping information to allow correct prompt re-rendering
+        Object.defineProperty(this, "height", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        Object.defineProperty(this, "extraLinesUnderPrompt", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        Object.defineProperty(this, "cursorPos", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.rl = rl;
+        this.cursorPos = rl.getCursorPos();
+    }
+    render(content, bottomContent = '') {
+        /**
+         * Write message to screen and setPrompt to control backspace
+         */
+        const promptLine = lastLine(content);
+        const rawPromptLine = (0, strip_ansi_1.default)(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) {
+            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 = (0, utils_mjs_1.readlineWidth)();
+        content = (0, utils_mjs_1.breakLines)(content, width);
+        bottomContent = (0, utils_mjs_1.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 += ansi_escapes_1.default.cursorUp(bottomContentHeight);
+        // Return cursor to the initial left offset.
+        output += ansi_escapes_1.default.cursorTo(this.cursorPos.cols);
+        this.clean();
+        this.rl.output.unmute();
+        /**
+         * Set up state for next re-rendering
+         */
+        this.extraLinesUnderPrompt = bottomContentHeight;
+        this.height = height(output);
+        this.rl.output.write(output);
+        this.rl.output.mute();
+    }
+    checkCursorPos() {
+        const cursorPos = this.rl.getCursorPos();
+        if (cursorPos.cols !== this.cursorPos.cols) {
+            this.rl.output.unmute();
+            this.rl.output.write(ansi_escapes_1.default.cursorTo(cursorPos.cols));
+            this.rl.output.mute();
+            this.cursorPos = cursorPos;
+        }
+    }
+    clean() {
+        this.rl.output.unmute();
+        this.rl.output.write([
+            this.extraLinesUnderPrompt > 0
+                ? ansi_escapes_1.default.cursorDown(this.extraLinesUnderPrompt)
+                : '',
+            ansi_escapes_1.default.eraseLines(this.height),
+        ].join(''));
+        this.extraLinesUnderPrompt = 0;
+        this.rl.output.mute();
+    }
+    clearContent() {
+        this.rl.output.unmute();
+        // Reset the cursor at the end of the previously displayed content
+        this.rl.output.write([
+            this.extraLinesUnderPrompt > 0
+                ? ansi_escapes_1.default.cursorDown(this.extraLinesUnderPrompt)
+                : '',
+            '\n',
+        ].join(''));
+        this.rl.output.mute();
+    }
+    done() {
+        this.rl.setPrompt('');
+        this.rl.output.unmute();
+        this.rl.output.write(ansi_escapes_1.default.cursorShow);
+        this.rl.output.end();
+        this.rl.close();
+    }
+}
+exports.default = ScreenManager;

package/node_modules/@inquirer/core/dist/cjs/lib/theme.js

@@ -0,0 +1,24 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultTheme = void 0;
+const chalk_1 = __importDefault(require("chalk"));
+const cli_spinners_1 = __importDefault(require("cli-spinners"));
+exports.defaultTheme = {
+    prefix: chalk_1.default.green('?'),
+    spinner: {
+        interval: cli_spinners_1.default.dots.interval,
+        frames: cli_spinners_1.default.dots.frames.map((frame) => chalk_1.default.yellow(frame)),
+    },
+    style: {
+        answer: chalk_1.default.cyan,
+        message: chalk_1.default.bold,
+        error: (text) => chalk_1.default.red(`> ${text}`),
+        defaultAnswer: (text) => chalk_1.default.dim(`(${text})`),
+        help: chalk_1.default.dim,
+        highlight: chalk_1.default.cyan,
+        key: (text) => chalk_1.default.cyan.bold(`<${text}>`),
+    },
+};

package/node_modules/@inquirer/core/dist/cjs/lib/use-effect.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useEffect = void 0;
+const hook_engine_mjs_1 = require('./hook-engine.js');
+function useEffect(cb, depArray) {
+    (0, hook_engine_mjs_1.withPointer)((pointer) => {
+        const oldDeps = pointer.get();
+        const hasChanged = !Array.isArray(oldDeps) || depArray.some((dep, i) => !Object.is(dep, oldDeps[i]));
+        if (hasChanged) {
+            hook_engine_mjs_1.effectScheduler.queue(cb);
+        }
+        pointer.set(depArray);
+    });
+}
+exports.useEffect = useEffect;

package/node_modules/@inquirer/core/dist/cjs/lib/use-keypress.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useKeypress = void 0;
+const use_ref_mjs_1 = require('./use-ref.js');
+const use_effect_mjs_1 = require('./use-effect.js');
+const hook_engine_mjs_1 = require('./hook-engine.js');
+function useKeypress(userHandler) {
+    const signal = (0, use_ref_mjs_1.useRef)(userHandler);
+    signal.current = userHandler;
+    (0, use_effect_mjs_1.useEffect)((rl) => {
+        const handler = (0, hook_engine_mjs_1.withUpdates)((_input, event) => {
+            signal.current(event, rl);
+        });
+        rl.input.on('keypress', handler);
+        return () => {
+            rl.input.removeListener('keypress', handler);
+        };
+    }, []);
+}
+exports.useKeypress = useKeypress;

package/node_modules/@inquirer/core/dist/cjs/lib/use-memo.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useMemo = void 0;
+const hook_engine_mjs_1 = require('./hook-engine.js');
+function useMemo(fn, dependencies) {
+    return (0, hook_engine_mjs_1.withPointer)((pointer) => {
+        const prev = pointer.get();
+        if (!prev ||
+            prev.dependencies.length !== dependencies.length ||
+            prev.dependencies.some((dep, i) => dep !== dependencies[i])) {
+            const value = fn();
+            pointer.set({ value, dependencies });
+            return value;
+        }
+        return prev.value;
+    });
+}
+exports.useMemo = useMemo;

package/node_modules/@inquirer/core/dist/cjs/lib/use-prefix.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.usePrefix = void 0;
+const node_async_hooks_1 = require("node:async_hooks");
+const use_state_mjs_1 = require('./use-state.js');
+const use_effect_mjs_1 = require('./use-effect.js');
+const make_theme_mjs_1 = require('./make-theme.js');
+function usePrefix({ isLoading = false, theme, }) {
+    const [tick, setTick] = (0, use_state_mjs_1.useState)(0);
+    const { prefix, spinner } = (0, make_theme_mjs_1.makeTheme)(theme);
+    (0, use_effect_mjs_1.useEffect)(() => {
+        if (isLoading) {
+            const timeout = setTimeout(node_async_hooks_1.AsyncResource.bind(() => {
+                setTick(tick + 1);
+            }), spinner.interval);
+            return () => clearTimeout(timeout);
+        }
+    }, [isLoading, tick]);
+    if (isLoading) {
+        const frame = tick % spinner.frames.length;
+        return spinner.frames[frame];
+    }
+    return prefix;
+}
+exports.usePrefix = usePrefix;

package/node_modules/@inquirer/core/dist/cjs/lib/use-ref.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useRef = void 0;
+const use_state_mjs_1 = require('./use-state.js');
+function useRef(val) {
+    return (0, use_state_mjs_1.useState)({ current: val })[0];
+}
+exports.useRef = useRef;

package/node_modules/@inquirer/core/dist/cjs/lib/use-state.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useState = void 0;
+const hook_engine_mjs_1 = require('./hook-engine.js');
+function useState(defaultValue) {
+    return (0, hook_engine_mjs_1.withPointer)((pointer) => {
+        const setFn = (newValue) => {
+            // Noop if the value is still the same.
+            if (pointer.get() !== newValue) {
+                pointer.set(newValue);
+                // Trigger re-render
+                (0, hook_engine_mjs_1.handleChange)();
+            }
+        };
+        if (pointer.initialized) {
+            return [pointer.get(), setFn];
+        }
+        const value = typeof defaultValue === 'function' ? defaultValue() : defaultValue;
+        pointer.set(value);
+        return [value, setFn];
+    });
+}
+exports.useState = useState;

package/node_modules/@inquirer/core/dist/cjs/lib/utils.js

@@ -0,0 +1,33 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readlineWidth = exports.breakLines = void 0;
+const cli_width_1 = __importDefault(require("cli-width"));
+const wrap_ansi_1 = __importDefault(require("wrap-ansi"));
+const hook_engine_mjs_1 = require('./hook-engine.js');
+/**
+ * Force line returns at specific width. This function is ANSI code friendly and it'll
+ * ignore invisible codes during width calculation.
+ * @param {string} content
+ * @param {number} width
+ * @return {string}
+ */
+function breakLines(content, width) {
+    return content
+        .split('\n')
+        .flatMap((line) => (0, wrap_ansi_1.default)(line, width, { trim: false, hard: true })
+        .split('\n')
+        .map((str) => str.trimEnd()))
+        .join('\n');
+}
+exports.breakLines = breakLines;
+/**
+ * Returns the width of the active readline, or 80 as default value.
+ * @returns {number}
+ */
+function readlineWidth() {
+    return (0, cli_width_1.default)({ defaultWidth: 80, output: (0, hook_engine_mjs_1.readline)().output });
+}
+exports.readlineWidth = readlineWidth;

package/node_modules/@inquirer/core/dist/cjs/types/index.d.ts

@@ -0,0 +1,14 @@
+export * from './lib/key.js';
+export * from './lib/errors.js';
+export { usePrefix } from './lib/use-prefix.js';
+export { useState } from './lib/use-state.js';
+export { useEffect } from './lib/use-effect.js';
+export { useMemo } from './lib/use-memo.js';
+export { useRef } from './lib/use-ref.js';
+export { useKeypress } from './lib/use-keypress.js';
+export { makeTheme } from './lib/make-theme.js';
+export type { Theme } from './lib/theme.js';
+export { usePagination } from './lib/pagination/use-pagination.js';
+export { createPrompt } from './lib/create-prompt.js';
+export { Separator } from './lib/Separator.js';
+export { type InquirerReadline } from './lib/read-line.type.js';

package/node_modules/@inquirer/core/dist/cjs/types/lib/Separator.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Separator object
+ * Used to space/separate choices group
+ */
+export declare class Separator {
+    readonly separator: string;
+    readonly type = "separator";
+    constructor(separator?: string);
+    static isSeparator(choice: undefined | Separator | Record<string, unknown>): choice is Separator;
+}

package/node_modules/@inquirer/core/dist/cjs/types/lib/create-prompt.d.ts

@@ -0,0 +1,4 @@
+import { type Prompt, type Prettify } from '@inquirer/type';
+type ViewFunction<Value, Config> = (config: Prettify<Config>, done: (value: Value) => void) => string | [string, string | undefined];
+export declare function createPrompt<Value, Config>(view: ViewFunction<Value, Config>): Prompt<Value, Config>;
+export {};

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

@@ -0,0 +1,9 @@
+export declare class CancelPromptError extends Error {
+    message: string;
+}
+export declare class ExitPromptError extends Error {
+}
+export declare class HookError extends Error {
+}
+export declare class ValidationError extends Error {
+}

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

@@ -0,0 +1,30 @@
+import type { InquirerReadline } from './read-line.type.js';
+type HookStore = {
+    rl: InquirerReadline;
+    hooks: any[];
+    hooksCleanup: Array<void | (() => void)>;
+    hooksEffect: Array<() => void>;
+    index: number;
+    handleChange: () => void;
+};
+export declare function withHooks(rl: InquirerReadline, cb: (store: HookStore) => void): void;
+export declare function readline(): InquirerReadline;
+export declare function withUpdates<T extends (...args: any) => any>(fn: T): (...args: Parameters<T>) => ReturnType<T>;
+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;
+    run(): void;
+};
+export {};

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

@@ -0,0 +1,10 @@
+export type KeypressEvent = {
+    name: string;
+    ctrl: boolean;
+};
+export declare const isUpKey: (key: KeypressEvent) => boolean;
+export declare const isDownKey: (key: KeypressEvent) => boolean;
+export declare const isSpaceKey: (key: KeypressEvent) => boolean;
+export declare const isBackspaceKey: (key: KeypressEvent) => boolean;
+export declare const isNumberKey: (key: KeypressEvent) => boolean;
+export declare const isEnterKey: (key: KeypressEvent) => boolean;

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

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

package/node_modules/@inquirer/core/dist/cjs/types/lib/pagination/lines.d.ts

@@ -0,0 +1,26 @@
+import { type Prettify } from '@inquirer/type';
+/** Represents an item that's part of a layout, about to be rendered */
+export type Layout<T> = {
+    item: T;
+    index: number;
+    isActive: boolean;
+};
+/**
+ * Renders a page of items as lines that fit within the given width ensuring
+ * that the number of lines is not greater than the page size, and the active
+ * item renders at the provided position, while prioritizing that as many lines
+ * of the active item get rendered as possible.
+ */
+export declare function lines<T>({ items, width, renderItem, active, position: requested, pageSize, }: {
+    items: readonly T[];
+    /** The width of a rendered line in characters. */
+    width: number;
+    /** Renders an item as part of a page. */
+    renderItem: (layout: Prettify<Layout<T>>) => string;
+    /** The index of the active item in the list of items. */
+    active: number;
+    /** The position on the page at which to render the active item. */
+    position: number;
+    /** The number of lines to render per page. */
+    pageSize: number;
+}): string[];

package/node_modules/@inquirer/core/dist/cjs/types/lib/pagination/position.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Creates the next position for the active item considering a finite list of
+ * items to be rendered on a page.
+ */
+export declare function finite({ active, pageSize, total, }: {
+    active: number;
+    pageSize: number;
+    total: number;
+}): number;
+/**
+ * Creates the next position for the active item considering an infinitely
+ * looping list of items to be rendered on the page.
+ */
+export declare function infinite({ active, lastActive, total, pageSize, pointer, }: {
+    active: number;
+    lastActive: number;
+    total: number;
+    pageSize: number;
+    pointer: number;
+}): number;

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

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

package/node_modules/@inquirer/core/dist/cjs/types/lib/read-line.type.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import * as readline from 'node:readline';
+import MuteStream from 'mute-stream';
+export type InquirerReadline = readline.ReadLine & {
+    output: MuteStream;
+    input: NodeJS.ReadableStream;
+    clearLine: (dir: 0 | 1 | -1) => void;
+};

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

@@ -0,0 +1,13 @@
+import type { InquirerReadline } from './read-line.type.js';
+export default class ScreenManager {
+    private readonly rl;
+    private height;
+    private extraLinesUnderPrompt;
+    private cursorPos;
+    constructor(rl: InquirerReadline);
+    render(content: string, bottomContent?: string): void;
+    checkCursorPos(): void;
+    clean(): void;
+    clearContent(): void;
+    done(): void;
+}

package/node_modules/@inquirer/core/dist/cjs/types/lib/theme.d.ts

@@ -0,0 +1,20 @@
+import type { Prettify } from '@inquirer/type';
+type DefaultTheme = {
+    prefix: string;
+    spinner: {
+        interval: number;
+        frames: string[];
+    };
+    style: {
+        answer: (text: string) => string;
+        message: (text: string) => string;
+        error: (text: string) => string;
+        defaultAnswer: (text: string) => string;
+        help: (text: string) => string;
+        highlight: (text: string) => string;
+        key: (text: string) => string;
+    };
+};
+export type Theme<Extension extends {} = {}> = Prettify<Extension & DefaultTheme>;
+export declare const defaultTheme: DefaultTheme;
+export {};