silvery 0.17.0 → 0.17.2

package/dist/wrappers-hhL8EQ_n.mjs

@@ -0,0 +1,810 @@
+import { a as chalk, r as Spinner } from "./spinner-DSByknyx.mjs";
+import { f as isTTY, i as CURSOR_HIDE, m as write, s as CURSOR_SHOW, u as cursorUp } from "./ansi-CXLE_pt1.mjs";
+import { t as ProgressBar } from "./progress-bar-COPSBlT9.mjs";
+//#region packages/ag-react/src/ui/wrappers/with-spinner.ts
+/**
+* Wrap a promise with an animated spinner
+*
+* @example
+* ```ts
+* // Simple usage
+* const data = await withSpinner(fetchData(), "Loading data...");
+*
+* // With options
+* const result = await withSpinner(
+*   processFiles(),
+*   "Processing...",
+*   { style: "arc", clearOnComplete: true }
+* );
+*
+* // With dynamic text
+* const result = await withSpinner(
+*   longOperation(),
+*   (elapsed) => `Processing... (${elapsed}s)`
+* );
+* ```
+*/
+async function withSpinner(promise, text, options = {}) {
+	const spinner = new Spinner({
+		text: typeof text === "string" ? text : text(0),
+		style: options.style,
+		color: options.color
+	});
+	let timer = null;
+	const startTime = Date.now();
+	spinner.start();
+	if (typeof text === "function") timer = setInterval(() => {
+		spinner.currentText = text(Math.floor((Date.now() - startTime) / 1e3));
+	}, 1e3);
+	try {
+		const result = await (typeof promise === "function" ? promise() : promise);
+		if (timer) clearInterval(timer);
+		if (options.clearOnComplete) spinner.stop();
+		else spinner.succeed();
+		return result;
+	} catch (error) {
+		if (timer) clearInterval(timer);
+		spinner.fail(error instanceof Error ? error.message : "Failed");
+		throw error;
+	}
+}
+/**
+* Attach a spinner to a promise for manual control
+* Returns [result, spinner] tuple for custom control
+*
+* @example
+* ```ts
+* const [promise, spinner] = attachSpinner(fetchData(), "Loading...");
+* spinner.text = "Still loading...";
+* const result = await promise;
+* spinner.succeed("Loaded!");
+* ```
+*/
+function attachSpinner(promise, text, options = {}) {
+	const spinner = new Spinner({
+		text,
+		style: options.style,
+		color: options.color
+	});
+	spinner.start();
+	async function wrapPromise() {
+		try {
+			return await promise;
+		} catch (error) {
+			spinner.fail(error instanceof Error ? error.message : "Failed");
+			throw error;
+		}
+	}
+	return [wrapPromise(), spinner];
+}
+//#endregion
+//#region packages/ag-react/src/ui/wrappers/with-progress.ts
+/**
+* Wrap a function that takes a progress callback
+*
+* @example
+* ```ts
+* // Wrap existing km sync API
+* const result = await withProgress(
+*   (onProgress) => manager.syncFromFs(onProgress),
+*   {
+*     phases: {
+*       scanning: "Scanning files",
+*       reconciling: "Reconciling changes",
+*       rules: "Evaluating rules"
+*     }
+*   }
+* );
+*
+* // Simple usage without phases
+* await withProgress((onProgress) => rebuildState(onProgress));
+*
+* // With custom format
+* await withProgress(
+*   (p) => processFiles(p),
+*   { format: ":phase :bar :percent" }
+* );
+*
+* // Show loading immediately (showAfter: 0) or after delay
+* await withProgress(
+*   (p) => slowOperation(p),
+*   { showAfter: 1000, initialMessage: "Loading..." }
+* );
+* ```
+*/
+async function withProgress(fn, options = {}) {
+	const stream = process.stdout;
+	const isTty = isTTY(stream);
+	const bar = new ProgressBar({
+		format: options.format ?? (options.phases ? ":phase [:bar] :current/:total" : "[:bar] :current/:total :percent"),
+		phases: options.phases ?? {},
+		hideCursor: true
+	});
+	let lastPhase = null;
+	let started = false;
+	const showAfter = options.showAfter ?? 1e3;
+	const initialMessage = options.initialMessage ?? "Loading...";
+	let spinner = null;
+	let spinnerTimerId = null;
+	if (isTty) write(CURSOR_HIDE, stream);
+	if (isTty && showAfter >= 0) spinnerTimerId = setTimeout(() => {
+		if (!started) {
+			spinner = new Spinner({ text: initialMessage });
+			spinner.start();
+		}
+	}, showAfter);
+	const onProgress = (info) => {
+		if (spinner) {
+			spinner.stop();
+			spinner = null;
+		}
+		if (spinnerTimerId !== null) {
+			clearTimeout(spinnerTimerId);
+			spinnerTimerId = null;
+		}
+		if (info.phase && info.phase !== lastPhase) {
+			if (lastPhase !== null && isTty) write("\n", stream);
+			lastPhase = info.phase;
+			if (!started) {
+				bar.start(info.current, info.total);
+				started = true;
+			}
+			bar.setPhase(info.phase, {
+				current: info.current,
+				total: info.total
+			});
+		} else {
+			if (!started) {
+				bar.start(info.current, info.total);
+				started = true;
+			}
+			bar.update(info.current);
+		}
+	};
+	try {
+		const result = await fn(onProgress);
+		if (spinnerTimerId !== null) clearTimeout(spinnerTimerId);
+		const pendingSpinner = spinner;
+		if (pendingSpinner) pendingSpinner.stop();
+		if (started) bar.stop(options.clearOnComplete);
+		if (isTty) write(CURSOR_SHOW, stream);
+		return result;
+	} catch (error) {
+		if (spinnerTimerId !== null) clearTimeout(spinnerTimerId);
+		const errorSpinner = spinner;
+		if (errorSpinner) errorSpinner.stop();
+		if (started) bar.stop();
+		if (isTty) write(CURSOR_SHOW, stream);
+		throw error;
+	}
+}
+/**
+* Create a progress callback that can be passed to existing APIs
+* Returns [callback, complete] tuple
+*
+* @example
+* ```ts
+* const [onProgress, complete] = createProgressCallback({
+*   phases: { scanning: "Scanning", reconciling: "Reconciling" }
+* });
+*
+* const result = await manager.syncFromFs(onProgress);
+* complete();
+* ```
+*/
+function createProgressCallback(options = {}) {
+	const stream = process.stdout;
+	const isTty = isTTY(stream);
+	const bar = new ProgressBar({
+		format: options.format ?? (options.phases ? ":phase [:bar] :current/:total" : "[:bar] :current/:total :percent"),
+		phases: options.phases ?? {},
+		hideCursor: true
+	});
+	let lastPhase = null;
+	let started = false;
+	if (isTty) write(CURSOR_HIDE, stream);
+	const callback = (info) => {
+		if (info.phase && info.phase !== lastPhase) {
+			if (lastPhase !== null && isTty) write("\n", stream);
+			lastPhase = info.phase;
+			if (!started) {
+				bar.start(info.current, info.total);
+				started = true;
+			}
+			bar.setPhase(info.phase, {
+				current: info.current,
+				total: info.total
+			});
+		} else {
+			if (!started) {
+				bar.start(info.current, info.total);
+				started = true;
+			}
+			bar.update(info.current);
+		}
+	};
+	const complete = () => {
+		if (started) bar.stop(options.clearOnComplete);
+		if (isTty) write(CURSOR_SHOW, stream);
+	};
+	return [callback, complete];
+}
+//#endregion
+//#region packages/ag-react/src/ui/wrappers/wrap-generator.ts
+/**
+* Consume a progress generator while displaying progress
+*
+* @example
+* ```ts
+* // Wrap existing generator (like evaluateAllRules())
+* await wrapGenerator(evaluateAllRules(), "Evaluating rules");
+*
+* // With custom format
+* await wrapGenerator(
+*   processItems(),
+*   ({ current, total }) => `Processing: ${current}/${total}`
+* );
+*
+* // Get the generator's return value
+* const result = await wrapGenerator(generatorWithReturn(), "Processing");
+* ```
+*/
+async function wrapGenerator(generator, textOrFormat, options = {}) {
+	const stream = process.stdout;
+	const isTty = isTTY(stream);
+	const label = typeof textOrFormat === "function" ? "" : textOrFormat;
+	const bar = new ProgressBar({
+		format: label ? `${label} [:bar] :current/:total :percent` : ":bar :current/:total :percent",
+		hideCursor: true
+	});
+	if (isTty) write(CURSOR_HIDE, stream);
+	let started = false;
+	let result;
+	try {
+		while (true) {
+			result = generator.next();
+			if (result.done) break;
+			const { current, total } = result.value;
+			if (!started) {
+				bar.start(current, total);
+				started = true;
+			} else bar.update(current);
+		}
+		if (started) bar.stop(options.clearOnComplete);
+		if (isTty) write(CURSOR_SHOW, stream);
+		return result.value;
+	} catch (error) {
+		if (started) bar.stop();
+		if (isTty) write(CURSOR_SHOW, stream);
+		throw error;
+	}
+}
+/**
+* Create an async iterable wrapper that shows progress
+*
+* @example
+* ```ts
+* const items = [1, 2, 3, 4, 5];
+* for await (const item of withIterableProgress(items, "Processing")) {
+*   await processItem(item);
+* }
+* ```
+*/
+async function* withIterableProgress(iterable, label, options = {}) {
+	const stream = process.stdout;
+	const isTty = isTTY(stream);
+	const total = (Array.isArray(iterable) ? iterable : null)?.length ?? 0;
+	const bar = new ProgressBar({
+		format: `${label} [:bar] :current/:total :percent`,
+		total,
+		hideCursor: true
+	});
+	if (isTty) write(CURSOR_HIDE, stream);
+	let current = 0;
+	bar.start(0, total);
+	try {
+		for await (const item of iterable) {
+			yield item;
+			current++;
+			bar.update(current);
+		}
+		bar.stop(options.clearOnComplete);
+		if (isTty) write(CURSOR_SHOW, stream);
+	} catch (error) {
+		bar.stop();
+		if (isTty) write(CURSOR_SHOW, stream);
+		throw error;
+	}
+}
+//#endregion
+//#region packages/ag-react/src/ui/wrappers/wrap-emitter.ts
+/**
+* Track EventEmitter state changes with a spinner
+*
+* @example
+* ```ts
+* const stop = wrapEmitter(syncManager, {
+*   initialText: "Starting sync...",
+*   events: {
+*     'ready': { text: "Watcher ready", succeed: true },
+*     'state-change': { getText: (s) => `State: ${s}` },
+*     'error': { fail: true },
+*     'idle': { stop: true }
+*   }
+* });
+*
+* // Later, to stop manually
+* stop();
+* ```
+*/
+function wrapEmitter(emitter, config) {
+	const spinner = new Spinner(config.initialText ?? "");
+	const handlers = /* @__PURE__ */ new Map();
+	spinner.start();
+	for (const [eventName, eventConfig] of Object.entries(config.events)) {
+		const handler = (data) => {
+			if (eventConfig.getText) spinner.currentText = eventConfig.getText(data);
+			else if (eventConfig.text) spinner.currentText = eventConfig.text;
+			if (eventConfig.succeed) {
+				spinner.succeed();
+				cleanup();
+			} else if (eventConfig.fail) {
+				const message = data instanceof Error ? data.message : String(data ?? "Failed");
+				spinner.fail(message);
+				cleanup();
+			} else if (eventConfig.stop) {
+				spinner.stop();
+				cleanup();
+			}
+		};
+		handlers.set(eventName, handler);
+		emitter.on(eventName, handler);
+	}
+	function cleanup() {
+		for (const [eventName, handler] of handlers) emitter.off(eventName, handler);
+		handlers.clear();
+	}
+	return () => {
+		spinner.stop();
+		cleanup();
+	};
+}
+/**
+* Wait for an EventEmitter to emit a specific event
+* Shows a spinner while waiting
+*
+* @example
+* ```ts
+* await waitForEvent(syncManager, "ready", "Waiting for watcher...");
+* ```
+*/
+async function waitForEvent(emitter, eventName, text, options = {}) {
+	return new Promise((resolve, reject) => {
+		const spinner = new Spinner(text);
+		spinner.start();
+		let timer = null;
+		const cleanup = () => {
+			emitter.off(eventName, successHandler);
+			if (options.errorEvent) emitter.off(options.errorEvent, errorHandler);
+			if (timer) clearTimeout(timer);
+		};
+		const successHandler = (data) => {
+			cleanup();
+			spinner.succeed();
+			resolve(data);
+		};
+		const errorHandler = (error) => {
+			cleanup();
+			spinner.fail(error instanceof Error ? error.message : "Error");
+			reject(error instanceof Error ? error : new Error(String(error)));
+		};
+		emitter.once(eventName, successHandler);
+		if (options.errorEvent) emitter.once(options.errorEvent, errorHandler);
+		if (options.timeout) timer = setTimeout(() => {
+			cleanup();
+			spinner.fail("Timeout");
+			reject(/* @__PURE__ */ new Error(`Timeout waiting for ${eventName}`));
+		}, options.timeout);
+	});
+}
+//#endregion
+//#region packages/ag-react/src/ui/wrappers/with-select.ts
+/**
+* withSelect - Interactive CLI selection list
+*/
+/**
+* Display an interactive selection list in the terminal
+*
+* @example
+* ```ts
+* // Simple usage
+* const color = await withSelect("Choose a color:", [
+*   { label: "Red", value: "red" },
+*   { label: "Green", value: "green" },
+*   { label: "Blue", value: "blue" },
+* ]);
+*
+* // With options
+* const result = await withSelect(
+*   "Select item:",
+*   options,
+*   { initial: 2, maxVisible: 5 }
+* );
+* ```
+*/
+async function withSelect(prompt, options, selectOptions = {}) {
+	const { initial = 0, maxVisible = 10 } = selectOptions;
+	const stream = process.stdout;
+	const stdin = process.stdin;
+	if (!isTTY(stream) || !stdin.isTTY) return options[initial]?.value ?? options[0].value;
+	return new Promise((resolve, reject) => {
+		let highlightIndex = Math.min(Math.max(0, initial), options.length - 1);
+		let linesRendered = 0;
+		stdin.setRawMode(true);
+		stdin.resume();
+		stdin.setEncoding("utf8");
+		write(CURSOR_HIDE, stream);
+		function render() {
+			if (linesRendered > 0) write(cursorUp(linesRendered), stream);
+			const scrollOffset = Math.max(0, Math.min(highlightIndex - Math.floor(maxVisible / 2), options.length - maxVisible));
+			const visibleCount = Math.min(maxVisible, options.length);
+			const visibleOptions = options.slice(scrollOffset, scrollOffset + visibleCount);
+			const hasMoreAbove = scrollOffset > 0;
+			const hasMoreBelow = scrollOffset + visibleCount < options.length;
+			write(`
+			let lines = 1;
+			if (hasMoreAbove) {
+				write(`
  ${chalk.dim("...")}\n`, stream);
+				lines++;
+			}
+			for (let i = 0; i < visibleOptions.length; i++) {
+				const option = visibleOptions[i];
+				const isHighlighted = scrollOffset + i === highlightIndex;
+				write(`
+				lines++;
+			}
+			if (hasMoreBelow) {
+				write(`
  ${chalk.dim("...")}\n`, stream);
+				lines++;
+			}
+			linesRendered = lines;
+		}
+		function cleanup() {
+			stdin.setRawMode(false);
+			stdin.pause();
+			stdin.removeListener("data", onKeypress);
+			write(CURSOR_SHOW, stream);
+		}
+		function onKeypress(key) {
+			key.charCodeAt(0);
+			if (key === "") {
+				cleanup();
+				reject(/* @__PURE__ */ new Error("User cancelled"));
+				return;
+			}
+			if (key === "\r" || key === "\n") {
+				cleanup();
+				resolve(options[highlightIndex].value);
+				return;
+			}
+			if (key === "\x1B" && key.length === 1) {
+				cleanup();
+				reject(/* @__PURE__ */ new Error("User cancelled"));
+				return;
+			}
+			if (key.startsWith("\x1B[")) {
+				const code = key.slice(2);
+				if (code === "A") {
+					highlightIndex = Math.max(0, highlightIndex - 1);
+					render();
+				} else if (code === "B") {
+					highlightIndex = Math.min(options.length - 1, highlightIndex + 1);
+					render();
+				}
+				return;
+			}
+			if (key === "j" || key === "J") {
+				highlightIndex = Math.min(options.length - 1, highlightIndex + 1);
+				render();
+				return;
+			}
+			if (key === "k" || key === "K") {
+				highlightIndex = Math.max(0, highlightIndex - 1);
+				render();
+				return;
+			}
+			if (key === " ") {
+				cleanup();
+				resolve(options[highlightIndex].value);
+				return;
+			}
+		}
+		stdin.on("data", onKeypress);
+		render();
+	});
+}
+/**
+* Create a reusable select instance for multiple selections
+*
+* @example
+* ```ts
+* const select = createSelect({
+*   maxVisible: 5,
+* });
+*
+* const first = await select("Choose first:", options1);
+* const second = await select("Choose second:", options2);
+* ```
+*/
+function createSelect(defaultOptions = {}) {
+	return (prompt, options, overrides = {}) => withSelect(prompt, options, {
+		...defaultOptions,
+		...overrides
+	});
+}
+//#endregion
+//#region packages/ag-react/src/ui/wrappers/with-text-input.ts
+/**
+* withTextInput - CLI wrapper for text input prompts
+*/
+/**
+* Prompt for text input in the terminal
+*
+* @example
+* ```ts
+* // Simple usage
+* const name = await withTextInput("What is your name?");
+*
+* // With options
+* const password = await withTextInput("Password:", { mask: "*" });
+*
+* // With validation
+* const email = await withTextInput("Email:", {
+*   validate: (v) => v.includes("@") ? undefined : "Invalid email"
+* });
+*
+* // With autocomplete
+* const fruit = await withTextInput("Pick a fruit:", {
+*   autocomplete: ["apple", "banana", "cherry"]
+* });
+* ```
+*/
+async function withTextInput(prompt, options = {}) {
+	const stream = options.stream ?? process.stdout;
+	const inputStream = options.inputStream ?? process.stdin;
+	const isTty = isTTY(stream);
+	let value = options.defaultValue ?? "";
+	let cursorPosition = value.length;
+	let errorMessage;
+	if (inputStream.isTTY) inputStream.setRawMode(true);
+	inputStream.resume();
+	const render = () => {
+		const displayValue = options.mask ? options.mask.repeat(value.length) : value;
+		const suggestion = getAutocompleteSuggestion(value, options.autocomplete);
+		const suggestionSuffix = suggestion ? chalk.dim(suggestion.slice(value.length)) : "";
+		const beforeCursor = displayValue.slice(0, cursorPosition);
+		const cursorChar = displayValue[cursorPosition] ?? " ";
+		const afterCursor = displayValue.slice(cursorPosition + 1);
+		const inputDisplay = !value && options.placeholder ? chalk.dim(options.placeholder) + chalk.inverse(" ") : beforeCursor + chalk.inverse(cursorChar) + afterCursor + suggestionSuffix;
+		const errorDisplay = errorMessage ? chalk.red(` (${errorMessage})`) : "";
+		const line = `${chalk.cyan("?")} ${chalk.bold(prompt)} ${inputDisplay}${errorDisplay}`;
+		if (isTty) write(`
+	};
+	if (isTty) write(CURSOR_HIDE, stream);
+	render();
+	return new Promise((resolve, reject) => {
+		const cleanup = () => {
+			inputStream.removeListener("data", onData);
+			inputStream.removeListener("error", onError);
+			if (inputStream.isTTY) inputStream.setRawMode(false);
+			inputStream.pause();
+			if (isTty) write(CURSOR_SHOW, stream);
+		};
+		const submit = () => {
+			if (options.validate) {
+				const error = options.validate(value);
+				if (error) {
+					errorMessage = error;
+					render();
+					return;
+				}
+			}
+			cleanup();
+			const displayValue = options.mask ? options.mask.repeat(value.length) : value;
+			write(`
+			resolve(value);
+		};
+		const onError = (err) => {
+			cleanup();
+			reject(err);
+		};
+		const onData = (data) => {
+			const input = data.toString();
+			errorMessage = void 0;
+			for (let i = 0; i < input.length; i++) {
+				const char = input[i];
+				const code = char.charCodeAt(0);
+				if (code === 13 || code === 10) {
+					submit();
+					return;
+				}
+				if (code === 3) {
+					cleanup();
+					write("\n", stream);
+					reject(/* @__PURE__ */ new Error("User aborted"));
+					return;
+				}
+				if (code === 27) {
+					if (input[i + 1] === "[") {
+						const arrowCode = input[i + 2];
+						if (arrowCode === "D") {
+							cursorPosition = Math.max(0, cursorPosition - 1);
+							i += 2;
+							continue;
+						}
+						if (arrowCode === "C") {
+							cursorPosition = Math.min(value.length, cursorPosition + 1);
+							i += 2;
+							continue;
+						}
+						if (arrowCode === "H") {
+							cursorPosition = 0;
+							i += 2;
+							continue;
+						}
+						if (arrowCode === "F") {
+							cursorPosition = value.length;
+							i += 2;
+							continue;
+						}
+						i += 2;
+						continue;
+					}
+					value = "";
+					cursorPosition = 0;
+					continue;
+				}
+				if (code === 127 || code === 8) {
+					if (cursorPosition > 0) {
+						value = value.slice(0, cursorPosition - 1) + value.slice(cursorPosition);
+						cursorPosition--;
+					}
+					continue;
+				}
+				if (code === 4) {
+					if (cursorPosition < value.length) value = value.slice(0, cursorPosition) + value.slice(cursorPosition + 1);
+					continue;
+				}
+				if (code === 9) {
+					const suggestion = getAutocompleteSuggestion(value, options.autocomplete);
+					if (suggestion) {
+						value = suggestion;
+						cursorPosition = value.length;
+					}
+					continue;
+				}
+				if (code === 1) {
+					cursorPosition = 0;
+					continue;
+				}
+				if (code === 5) {
+					cursorPosition = value.length;
+					continue;
+				}
+				if (code === 21) {
+					value = value.slice(cursorPosition);
+					cursorPosition = 0;
+					continue;
+				}
+				if (code === 11) {
+					value = value.slice(0, cursorPosition);
+					continue;
+				}
+				if (code === 23) {
+					const before = value.slice(0, cursorPosition);
+					const after = value.slice(cursorPosition);
+					const trimmed = before.trimEnd();
+					const lastSpace = trimmed.lastIndexOf(" ");
+					const newBefore = lastSpace === -1 ? "" : trimmed.slice(0, lastSpace + 1);
+					value = newBefore + after;
+					cursorPosition = newBefore.length;
+					continue;
+				}
+				if (code >= 32 && code < 127) {
+					value = value.slice(0, cursorPosition) + char + value.slice(cursorPosition);
+					cursorPosition++;
+					continue;
+				}
+				if (code > 127) {
+					value = value.slice(0, cursorPosition) + char + value.slice(cursorPosition);
+					cursorPosition++;
+					continue;
+				}
+			}
+			render();
+		};
+		inputStream.on("data", onData);
+		inputStream.on("error", onError);
+	});
+}
+/**
+* Create a text input instance for manual control
+*
+* @example
+* ```ts
+* const input = createTextInput("Name:", { placeholder: "Enter name" });
+* input.render();
+*
+* // Later, get the value
+* const value = await input.waitForSubmit();
+* ```
+*/
+function createTextInput(prompt, options = {}) {
+	const stream = options.stream ?? process.stdout;
+	const isTty = isTTY(stream);
+	let value = options.defaultValue ?? "";
+	let cursorPosition = value.length;
+	const render = () => {
+		const displayValue = options.mask ? options.mask.repeat(value.length) : value;
+		const suggestion = getAutocompleteSuggestion(value, options.autocomplete);
+		const suggestionSuffix = suggestion ? chalk.dim(suggestion.slice(value.length)) : "";
+		const beforeCursor = displayValue.slice(0, cursorPosition);
+		const cursorChar = displayValue[cursorPosition] ?? " ";
+		const afterCursor = displayValue.slice(cursorPosition + 1);
+		const inputDisplay = !value && options.placeholder ? chalk.dim(options.placeholder) + chalk.inverse(" ") : beforeCursor + chalk.inverse(cursorChar) + afterCursor + suggestionSuffix;
+		const line = `${chalk.cyan("?")} ${chalk.bold(prompt)} ${inputDisplay}`;
+		if (isTty) write(`
+	};
+	return {
+		get value() {
+			return value;
+		},
+		set value(v) {
+			value = v;
+			cursorPosition = Math.min(cursorPosition, v.length);
+		},
+		get cursorPosition() {
+			return cursorPosition;
+		},
+		set cursorPosition(pos) {
+			cursorPosition = Math.max(0, Math.min(value.length, pos));
+		},
+		render,
+		insert(char) {
+			value = value.slice(0, cursorPosition) + char + value.slice(cursorPosition);
+			cursorPosition += char.length;
+		},
+		backspace() {
+			if (cursorPosition > 0) {
+				value = value.slice(0, cursorPosition - 1) + value.slice(cursorPosition);
+				cursorPosition--;
+			}
+		},
+		delete() {
+			if (cursorPosition < value.length) value = value.slice(0, cursorPosition) + value.slice(cursorPosition + 1);
+		},
+		clear() {
+			value = "";
+			cursorPosition = 0;
+		},
+		acceptSuggestion() {
+			const suggestion = getAutocompleteSuggestion(value, options.autocomplete);
+			if (suggestion) {
+				value = suggestion;
+				cursorPosition = value.length;
+			}
+		}
+	};
+}
+/**
+* Find a matching autocomplete suggestion for the current input
+*/
+function getAutocompleteSuggestion(value, autocomplete) {
+	if (!value || !autocomplete?.length) return;
+	const lowerValue = value.toLowerCase();
+	return autocomplete.find((item) => item.toLowerCase().startsWith(lowerValue) && item.length > value.length);
+}
+//#endregion
+export { waitForEvent as a, wrapGenerator as c, attachSpinner as d, withSpinner as f, withSelect as i, createProgressCallback as l, withTextInput as n, wrapEmitter as o, createSelect as r, withIterableProgress as s, createTextInput as t, withProgress as u };
+
+//# sourceMappingURL=wrappers-hhL8EQ_n.mjs.map