create-openclaw-bot 5.2.0 → 5.2.1

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

@@ -0,0 +1,119 @@
+"use strict";
+/* eslint @typescript-eslint/no-explicit-any: ["off"] */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.effectScheduler = void 0;
+exports.withHooks = withHooks;
+exports.readline = readline;
+exports.withUpdates = withUpdates;
+exports.withPointer = withPointer;
+exports.handleChange = handleChange;
+const node_async_hooks_1 = require("node:async_hooks");
+const errors_mjs_1 = require('./errors.js');
+const hookStorage = new node_async_hooks_1.AsyncLocalStorage();
+function createStore(rl) {
+    const store = {
+        rl,
+        hooks: [],
+        hooksCleanup: [],
+        hooksEffect: [],
+        index: 0,
+        handleChange() { },
+    };
+    return store;
+}
+// Run callback in with the hook engine setup.
+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 errors_mjs_1.HookError('[Inquirer] Hook functions can only be called from within a prompt');
+    }
+    return store;
+}
+function readline() {
+    return getStore().rl;
+}
+// Merge state updates happening within the callback function to avoid multiple renders.
+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 node_async_hooks_1.AsyncResource.bind(wrapped);
+}
+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;
+}
+function handleChange() {
+    getStore().handleChange();
+}
+exports.effectScheduler = {
+    queue(cb) {
+        const store = getStore();
+        const { index } = store;
+        store.hooksEffect.push(() => {
+            var _a, _b;
+            (_b = (_a = store.hooksCleanup)[index]) === null || _b === void 0 ? void 0 : _b.call(_a);
+            const cleanFn = cb(readline());
+            if (cleanFn != null && typeof cleanFn !== 'function') {
+                throw new errors_mjs_1.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 === null || cleanFn === void 0 ? void 0 : cleanFn();
+        });
+        store.hooksEffect.length = 0;
+        store.hooksCleanup.length = 0;
+    },
+};

package/node_modules/@inquirer/editor/node_modules/@inquirer/core/dist/cjs/lib/key.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isEnterKey = exports.isNumberKey = exports.isBackspaceKey = exports.isSpaceKey = exports.isDownKey = exports.isUpKey = void 0;
+const isUpKey = (key) => 
+// The up key
+key.name === 'up' ||
+    // Vim keybinding
+    key.name === 'k' ||
+    // Emacs keybinding
+    (key.ctrl && key.name === 'p');
+exports.isUpKey = isUpKey;
+const isDownKey = (key) => 
+// The down key
+key.name === 'down' ||
+    // Vim keybinding
+    key.name === 'j' ||
+    // Emacs keybinding
+    (key.ctrl && key.name === 'n');
+exports.isDownKey = isDownKey;
+const isSpaceKey = (key) => key.name === 'space';
+exports.isSpaceKey = isSpaceKey;
+const isBackspaceKey = (key) => key.name === 'backspace';
+exports.isBackspaceKey = isBackspaceKey;
+const isNumberKey = (key) => '123456789'.includes(key.name);
+exports.isNumberKey = isNumberKey;
+const isEnterKey = (key) => key.name === 'enter' || key.name === 'return';
+exports.isEnterKey = isEnterKey;

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

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeTheme = makeTheme;
+const theme_mjs_1 = require('./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;
+}
+function makeTheme(...themes) {
+    const themesToMerge = [
+        theme_mjs_1.defaultTheme,
+        ...themes.filter((theme) => theme != null),
+    ];
+    return deepMerge(...themesToMerge);
+}

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

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lines = lines;
+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), ...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) => layoutsInPage[index] == null ? [] : split(renderItem(layoutsInPage[index]), width);
+    // Create a blank array of lines for the page
+    const pageBuffer = Array.from({ length: 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');
+}

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

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.finite = finite;
+exports.infinite = infinite;
+/**
+ * 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;
+}
+/**
+ * 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;
+}

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

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.usePagination = usePagination;
+const use_ref_mjs_1 = require('../use-ref.js');
+const utils_mjs_1 = require('../utils.js');
+const lines_mjs_1 = require('./lines.js');
+const position_mjs_1 = require('./position.js');
+function usePagination({ items, active, renderItem, pageSize, loop = true, }) {
+    const state = (0, use_ref_mjs_1.useRef)({ position: 0, lastActive: 0 });
+    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;
+    return (0, lines_mjs_1.lines)({
+        items,
+        width: (0, utils_mjs_1.readlineWidth)(),
+        renderItem,
+        active,
+        position,
+        pageSize,
+    }).join('\n');
+}

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

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PromisePolyfill = void 0;
+// TODO: Remove this class once Node 22 becomes the minimum supported version.
+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 };
+    }
+}
+exports.PromisePolyfill = PromisePolyfill;

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

@@ -0,0 +1,110 @@
+"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 : ''; };
+function cursorDown(n) {
+    return n > 0 ? ansi_escapes_1.default.cursorDown(n) : '';
+}
+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();
+    }
+    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 = (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 > 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 = (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);
+        /**
+         * Render and store state for future re-rendering
+         */
+        this.write(cursorDown(this.extraLinesUnderPrompt) +
+            ansi_escapes_1.default.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(ansi_escapes_1.default.cursorTo(cursorPos.cols));
+            this.cursorPos = cursorPos;
+        }
+    }
+    done({ clearContent }) {
+        this.rl.setPrompt('');
+        let output = cursorDown(this.extraLinesUnderPrompt);
+        output += clearContent ? ansi_escapes_1.default.eraseLines(this.height) : '\n';
+        output += ansi_escapes_1.default.cursorShow;
+        this.write(output);
+        this.rl.close();
+    }
+}
+exports.default = ScreenManager;

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

@@ -0,0 +1,28 @@
+"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 yoctocolors_cjs_1 = __importDefault(require("yoctocolors-cjs"));
+const figures_1 = __importDefault(require("@inquirer/figures"));
+exports.defaultTheme = {
+    prefix: {
+        idle: yoctocolors_cjs_1.default.blue('?'),
+        // TODO: use figure
+        done: yoctocolors_cjs_1.default.green(figures_1.default.tick),
+    },
+    spinner: {
+        interval: 80,
+        frames: ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'].map((frame) => yoctocolors_cjs_1.default.yellow(frame)),
+    },
+    style: {
+        answer: yoctocolors_cjs_1.default.cyan,
+        message: yoctocolors_cjs_1.default.bold,
+        error: (text) => yoctocolors_cjs_1.default.red(`> ${text}`),
+        defaultAnswer: (text) => yoctocolors_cjs_1.default.dim(`(${text})`),
+        help: yoctocolors_cjs_1.default.dim,
+        highlight: yoctocolors_cjs_1.default.cyan,
+        key: (text) => yoctocolors_cjs_1.default.cyan(yoctocolors_cjs_1.default.bold(`<${text}>`)),
+    },
+};

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

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useEffect = useEffect;
+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);
+    });
+}

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

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useKeypress = useKeypress;
+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) => {
+        let ignore = false;
+        const handler = (0, hook_engine_mjs_1.withUpdates)((_input, event) => {
+            if (ignore)
+                return;
+            void signal.current(event, rl);
+        });
+        rl.input.on('keypress', handler);
+        return () => {
+            ignore = true;
+            rl.input.removeListener('keypress', handler);
+        };
+    }, []);
+}

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

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useMemo = useMemo;
+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;
+    });
+}

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

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.usePrefix = usePrefix;
+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({ status = 'idle', theme, }) {
+    const [showLoader, setShowLoader] = (0, use_state_mjs_1.useState)(false);
+    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 (status === 'loading') {
+            let tickInterval;
+            let inc = -1;
+            // Delay displaying spinner by 300ms, to avoid flickering
+            const delayTimeout = setTimeout(node_async_hooks_1.AsyncResource.bind(() => {
+                setShowLoader(true);
+                tickInterval = setInterval(node_async_hooks_1.AsyncResource.bind(() => {
+                    inc = inc + 1;
+                    setTick(inc % spinner.frames.length);
+                }), spinner.interval);
+            }), 300);
+            return () => {
+                clearTimeout(delayTimeout);
+                clearInterval(tickInterval);
+            };
+        }
+        else {
+            setShowLoader(false);
+        }
+    }, [status]);
+    if (showLoader) {
+        return spinner.frames[tick];
+    }
+    // There's a delay before we show the loader. So we want to ignore `loading` here, and pass idle instead.
+    const iconName = status === 'loading' ? 'idle' : status;
+    return typeof prefix === 'string' ? prefix : prefix[iconName];
+}

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

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

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

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useState = useState;
+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];
+    });
+}

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

@@ -0,0 +1,32 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.breakLines = breakLines;
+exports.readlineWidth = readlineWidth;
+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');
+}
+/**
+ * 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 });
+}

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

@@ -0,0 +1,13 @@
+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, Status } 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';

package/node_modules/@inquirer/editor/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: unknown): choice is Separator;
+}

package/node_modules/@inquirer/editor/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 {};