@akterjs/cli 0.0.0-stage → 0.1.0

package/dist/TerminalCapabilities-w_44MAca.mjs

@@ -0,0 +1,1769 @@
+import { S as none, Tn as pipe, _ as isSome, bn as dual, f as getOrElse, qt as hasProperty, w as some, x as match } from "./Option-DkxSnBhp.mjs";
+import { $t as suspend, A as ensuring, B as flatMap$1, Et as orDie, Gt as scoped, M as fail, Nt as raceFirst, W as fnUntraced, Xt as succeed$1, _t as match$1, aa as Service, at as isEffect, dt as map$1, en as sync, f as cached, ht as mapError, ia as Reference, va as Prototype } from "./Effect-CKFpqbmw.mjs";
+import { L as reduce, M as match$2, d as findFirstIndex, f as findLast, j as map$2, o as empty, u as findFirst, w as isReadonlyArrayNonEmpty } from "./Array-B4kuTQeW.mjs";
+import { p as Error$1, sn as tag } from "./Schema-MiKt5K1v.mjs";
+import { a as taggedEnum } from "./Data-CeCULr0-.mjs";
+import { i as round } from "./Number-BvkRkfc-.mjs";
+import { g as take } from "./Queue-CO5UQ6os.mjs";
+import { n as make$1 } from "./Redacted-RkJrG5Me.mjs";
+// ../../node_modules/.pnpm/effect@4.1.2_patch_hash=0e61176203bb1256381ce1c5b488d7951983ce38ff698647d3f4617383abbf07/node_modules/effect/dist/Terminal.js
+const TypeId$1 = "~effect/Terminal";
+const QuitErrorTypeId = "~effect/Terminal/QuitError";
+/**
+* Represents an error that occurs when a user attempts to
+* quit out of a `Terminal` prompt for input (usually by entering `ctrl`+`c`).
+*
+* **When to use**
+*
+* Use when implementing terminal input or prompts that need to signal
+* user-requested cancellation through the typed error channel.
+*
+* @see {@link isQuitError} for checking unknown errors when handling terminal cancellation
+*
+* @stability unstable
+* @category errors
+* @since 4.0.0
+*/
+var QuitError = class extends (/*#__PURE__*/ Error$1("QuitError")({ _tag: /*#__PURE__*/ tag("QuitError") })) {
+	/**
+	* Marks this value as a terminal quit error for runtime guards.
+	*
+	* @since 4.0.0
+	*/
+	[QuitErrorTypeId] = QuitErrorTypeId;
+};
+/**
+* Returns `true` if the provided value is a `Terminal.QuitError`.
+*
+* **When to use**
+*
+* Use to narrow unknown failures to `QuitError` when handling terminal input
+* cancellation.
+*
+* **Details**
+*
+* Returns `true` when the value carries the `QuitError` runtime marker and
+* narrows it to `QuitError`.
+*
+* @see {@link QuitError} for the error value produced when terminal input is quit
+*
+* @stability unstable
+* @category guards
+* @since 4.0.0
+*/
+const isQuitError = (u) => hasProperty(u, QuitErrorTypeId);
+/**
+* Service tag for command-line input and output services.
+*
+* **When to use**
+*
+* Use to access or provide platform terminal capabilities such as reading
+* input, writing output, and inspecting terminal dimensions.
+*
+* @stability unstable
+* @category services
+* @since 4.0.0
+*/
+const Terminal = /*#__PURE__*/ Service("effect/Terminal");
+/**
+* Creates a `Terminal` service implementation.
+*
+* **When to use**
+*
+* Use to construct a custom `Terminal` service implementation from concrete
+* terminal capabilities when writing a platform adapter, test implementation,
+* or custom runtime service.
+*
+* **Details**
+*
+* The implementation object supplies `columns`, `rows`, `size`, `readInput`,
+* `readLine`, and `display`; `make` attaches the `Terminal` service marker so
+* the result can be provided through the `Terminal` context service.
+*
+* @stability unstable
+* @category constructors
+* @since 4.0.0
+*/
+const make = (impl) => Terminal.of({
+	...impl,
+	[TypeId$1]: TypeId$1
+});
+// ../../node_modules/.pnpm/effect@4.1.2_patch_hash=0e61176203bb1256381ce1c5b488d7951983ce38ff698647d3f4617383abbf07/node_modules/effect/dist/cli/internal/ansi.js
+/**
+* Internal ANSI escape sequence helpers used by the unstable CLI rendering
+* implementation. This module centralizes the control codes for text styling,
+* cursor movement, line erasing, and terminal notifications so renderers can
+* compose terminal output without scattering raw escape sequences throughout
+* the CLI internals.
+*
+* The helpers deliberately work with plain strings because terminal rendering
+* is sensitive to ordering: style codes must be reset after annotated text,
+* cursor operations must account for one-based terminal coordinates, and line
+* clearing usually needs to preserve the cursor position expected by the next
+* frame.
+*/
+const ESC = "\x1B[";
+const SEP = ";";
+/**
+* @internal
+*/
+const reset = `${ESC}0m`;
+/**
+* @internal
+*/
+const bold = `${ESC}1m`;
+/**
+* @internal
+*/
+const italicized = `${ESC}3m`;
+/**
+* @internal
+*/
+const underlined = `${ESC}4m`;
+/**
+* @internal
+*/
+const strikethrough = `${ESC}9m`;
+/**
+* @internal
+*/
+const cursorShow = `${ESC}?25h`;
+/**
+* @internal
+*/
+const cursorHide = `${ESC}?25l`;
+/**
+* @internal
+*/
+const eraseLine = `${ESC}2K`;
+/**
+* @internal
+*/
+const red = `${ESC}31m`;
+/**
+* @internal
+*/
+const green = `${ESC}32m`;
+/**
+* @internal
+*/
+const magenta = `${ESC}35m`;
+/**
+* @internal
+*/
+const white = `${ESC}37m`;
+/**
+* @internal
+*/
+const blackBright = `${ESC}90m`;
+/**
+* @internal
+*/
+const cyanBright = `${ESC}96m`;
+/**
+* Wraps `text` in the given styles followed by a reset. When `colors` is
+* `false` the text is returned unchanged, so callers gate color and style
+* escapes in one place while cursor and erase controls stay untouched.
+*
+* @internal
+*/
+const annotate = (colors, text, ...styles) => {
+	if (!colors) return text;
+	return `${styles.flat().join("")}${text}${reset}`;
+};
+/**
+* Detects whether CLI output should use color and style escapes: stdout must
+* be a TTY and `NO_COLOR` must be unset or empty.
+*
+* @internal
+*/
+const detectColors = () => {
+	const globalProcess = globalThis.process;
+	return typeof globalProcess === "object" && globalProcess !== null && typeof globalProcess.stdout === "object" && globalProcess.stdout !== null && globalProcess.stdout.isTTY === true && !globalProcess.env?.NO_COLOR;
+};
+const combine = (...styles) => styles;
+/**
+* @internal
+*/
+const cursorTo = (column, row) => {
+	if (row === void 0) return `${ESC}${Math.max(column + 1, 0)}G`;
+	return `${ESC}${row + 1}${SEP}${Math.max(column + 1, 0)}H`;
+};
+/**
+* @internal
+*/
+const cursorDown = (lines = 1) => {
+	return `${ESC}${lines}B`;
+};
+/**
+* @internal
+*/
+const cursorMove = (column, row = 0) => {
+	let command = "";
+	if (row < 0) command += `${ESC}${-row}A`;
+	if (row > 0) command += `${ESC}${row}B`;
+	if (column > 0) command += `${ESC}${column}C`;
+	if (column < 0) command += `${ESC}${-column}D`;
+	return command;
+};
+/**
+* @internal
+*/
+const eraseLines = (rows) => {
+	let command = "";
+	for (let i = 0; i < rows; i++) command += `${ESC}2K` + (i < rows - 1 ? `${ESC}1A` : "");
+	if (rows > 0) command += `${ESC}G`;
+	return command;
+};
+// ../../node_modules/.pnpm/effect@4.1.2_patch_hash=0e61176203bb1256381ce1c5b488d7951983ce38ff698647d3f4617383abbf07/node_modules/effect/dist/cli/Prompt.js
+/**
+* Builds interactive terminal prompts for CLI applications.
+*
+* A `Prompt<A>` describes a small terminal UI that renders frames, reads
+* keyboard input, validates responses, and eventually produces an `A`. Prompts
+* can ask for simple values, selections, lists, files, hidden text, or custom
+* interactions. This module includes prompt constructors, tools for combining
+* and transforming prompt output, and support for running prompts through the
+* `Terminal` service.
+*
+* @stability unstable
+* @since 4.0.0
+*/
+const TypeId = "~effect/cli/Prompt";
+const defaultTheme = {
+	prefix: "?",
+	arrowUp: "↑",
+	arrowDown: "↓",
+	checkboxOn: "☒",
+	checkboxOff: "☐",
+	tick: "✔",
+	ellipsis: "…",
+	pointerSmall: "›",
+	pointer: "❯",
+	descriptionSeparator: "- ",
+	passwordMask: "*",
+	toggleSeparator: "/",
+	primaryColor: cyanBright,
+	mutedColor: blackBright,
+	successColor: green,
+	errorColor: red,
+	submittedColor: white
+};
+const windowsTheme = {
+	...defaultTheme,
+	checkboxOn: "[*]",
+	checkboxOff: "[ ]",
+	tick: "√",
+	ellipsis: "...",
+	pointerSmall: "»",
+	pointer: ">"
+};
+/**
+* Creates a prompt theme using the current platform defaults.
+*
+* **Details**
+*
+* Unless `colors` is provided, it is detected when the theme is created:
+* colors are enabled when stdout is a TTY and `NO_COLOR` is unset or empty.
+*
+* @stability unstable
+* @category constructors
+* @since 4.0.0
+*/
+const makeTheme = (options) => ({
+	...process.platform === "win32" ? windowsTheme : defaultTheme,
+	...options,
+	colors: options?.colors ?? detectColors()
+});
+/**
+* Context reference for the theme used by built-in prompts.
+*
+* **Details**
+*
+* Provide this reference once to theme every prompt in an application. A
+* prompt's `theme` option takes precedence over the context value. The
+* command wizard also reads `colors` from this reference, so provide a theme
+* with `colors: false` to disable wizard styling.
+*
+* The default value is created with `makeTheme` the first time it is read,
+* so color detection runs once per process. Changes to `NO_COLOR` after the
+* first prompt do not affect the default theme.
+*
+* @stability unstable
+* @category services
+* @since 4.0.0
+*/
+const Theme = /*#__PURE__*/ Reference("effect/cli/Prompt/Theme", { defaultValue: makeTheme });
+const getTheme = (options) => map$1(Theme, (theme) => ({
+	...theme,
+	...options.theme
+}));
+const annotateErrorLine = (theme, line) => annotate(theme.colors, line, combine(italicized, theme.errorColor));
+const annotateSymbol = (theme, symbol, ...styles) => symbol.length === 0 ? "" : annotate(theme.colors, symbol, ...styles);
+const separateSymbol = (symbol, text) => symbol.length === 0 ? text : symbol + " " + text;
+const renderPagingPrefix = (theme, showArrowUp, showArrowDown) => {
+	const width = Math.max(theme.arrowUp.length, theme.arrowDown.length);
+	if (showArrowUp) return theme.arrowUp.padEnd(width);
+	if (showArrowDown) return theme.arrowDown.padEnd(width);
+	return " ".repeat(width);
+};
+/**
+* Creates a confirmation prompt that asks the user to choose a boolean yes/no
+* value.
+*
+* **When to use**
+*
+* Use to ask for a yes/no answer that can be submitted directly.
+*
+* **Details**
+*
+* `initial` defaults to `false`. Enter submits the current default, yes-style
+* input submits `true`, no-style input submits `false`, and other input beeps.
+*
+* @see {@link Toggle} for an interactive switch-before-submit boolean prompt
+*
+* @stability unstable
+* @category constructors
+* @since 4.0.0
+*/
+const Confirm = (options) => {
+	const opts = {
+		initial: false,
+		...options,
+		label: {
+			confirm: "yes",
+			deny: "no",
+			...options.label
+		},
+		placeholder: {
+			defaultConfirm: "(Y/n)",
+			defaultDeny: "(y/N)",
+			...options.placeholder
+		}
+	};
+	const initialState = { value: opts.initial };
+	return Custom(initialState, {
+		render: handleConfirmRender(opts),
+		process: (input) => handleConfirmProcess(input, opts.initial),
+		clear: handleConfirmClear(opts)
+	});
+};
+/**
+* Creates a custom `Prompt` from the specified initial state and handlers.
+*
+* **Details**
+*
+* The initial state can either be a pure value or an `Effect`. This is
+* particularly useful when the initial state of the `Prompt` must be computed
+* by performing an effectful computation, such as reading data from the file
+* system. A `Prompt` runs as a render loop: `render` returns ANSI output for
+* the current frame, the `Terminal` obtains user input, `process` returns the
+* next prompt action, and `clear` returns ANSI output used to clear the previous
+* frame.
+*
+* Optionally, an external `events` dequeue can be provided as the third
+* argument. When present, the render loop will race user input against events
+* from the dequeue, allowing background events to trigger re-renders without
+* waiting for a keypress. When an event is received from the dequeue, the
+* `receive` handler is called instead of `process`.
+*
+* @stability unstable
+* @category constructors
+* @since 4.0.0
+*/
+const Custom = (initialState, ...args) => {
+	const [events, handlers] = args.length === 1 ? [void 0, args[0]] : [args[0], args[1]];
+	const op = Object.create(proto);
+	op._tag = "Loop";
+	op.initialState = initialState;
+	op.render = handlers.render;
+	op.process = handlers.process;
+	op.clear = handlers.clear;
+	op.events = events;
+	return op;
+};
+/**
+* Creates a date prompt that lets the user edit a formatted date value and
+* validates the final `Date` before submission.
+*
+* **Details**
+*
+* `initial` defaults to the current `Date`, `dateMask` defaults to
+* `YYYY-MM-DD HH:mm:ss`, mask parsing creates editable date parts plus literal
+* tokens, `locales` customizes month and weekday labels, and `validate` runs on
+* submission.
+*
+* **Gotchas**
+*
+* A supplied `initial` `Date` is edited in place during prompt interaction.
+* Date edits use JavaScript `Date` setters, so out-of-range typed values can
+* normalize before validation. If the prompt is meant to be editable,
+* `dateMask` should contain at least one editable date token.
+*
+* @stability unstable
+* @category constructors
+* @since 4.0.0
+*/
+const Date = (options) => {
+	const opts = {
+		initial: new globalThis.Date(),
+		dateMask: "YYYY-MM-DD HH:mm:ss",
+		validate: succeed$1,
+		...options,
+		locales: {
+			...defaultLocales,
+			...options.locales
+		}
+	};
+	const dateParts = makeDateParts(opts.dateMask, opts.initial, opts.locales);
+	const initialState = {
+		dateParts,
+		typed: "",
+		cursor: dateParts.findIndex((part) => !part.isToken()),
+		value: opts.initial,
+		error: none()
+	};
+	return Custom(initialState, {
+		render: handleDateRender(opts),
+		process: handleDateProcess(opts),
+		clear: handleDateClear(opts)
+	});
+};
+/**
+* Composes prompts by using the output of this prompt to create the next prompt.
+*
+* @stability unstable
+* @category combinators
+* @since 4.0.0
+*/
+const flatMap = /*#__PURE__*/ dual(2, (self, f) => {
+	const op = Object.create(proto);
+	op._tag = "OnSuccess";
+	op.prompt = self;
+	op.onSuccess = f;
+	return op;
+});
+/**
+* Creates a floating-point number prompt.
+*
+* **Details**
+*
+* The prompt supports minimum and maximum bounds, keyboard step sizes, display
+* precision, and additional validation before submission.
+*
+* @stability unstable
+* @category constructors
+* @since 4.0.0
+*/
+const Number = (options) => {
+	const opts = {
+		default: 0,
+		min: globalThis.Number.NEGATIVE_INFINITY,
+		max: globalThis.Number.POSITIVE_INFINITY,
+		incrementBy: 1,
+		decrementBy: 1,
+		precision: 2,
+		validate: (n) => {
+			if (n < opts.min) return fail(`${n} must be greater than or equal to ${opts.min}`);
+			if (n > opts.max) return fail(`${n} must be less than or equal to ${opts.max}`);
+			return succeed$1(n);
+		},
+		...options
+	};
+	const initialValue = options.default === void 0 ? "" : `${opts.default}`;
+	const initialState = {
+		cursor: initialValue.length,
+		value: initialValue,
+		error: none()
+	};
+	return Custom(initialState, {
+		render: handleRenderFloat(opts),
+		process: handleProcessFloat(opts),
+		clear: handleNumberClear(opts)
+	});
+};
+/**
+* Creates an integer prompt.
+*
+* **Details**
+*
+* The prompt supports minimum and maximum bounds, keyboard step sizes, and
+* additional validation before submission.
+*
+* @stability unstable
+* @category constructors
+* @since 4.0.0
+*/
+const Int = (options) => {
+	const opts = {
+		default: 0,
+		min: globalThis.Number.NEGATIVE_INFINITY,
+		max: globalThis.Number.POSITIVE_INFINITY,
+		incrementBy: 1,
+		decrementBy: 1,
+		validate: (n) => {
+			if (n < opts.min) return fail(`${n} must be greater than or equal to ${opts.min}`);
+			if (n > opts.max) return fail(`${n} must be less than or equal to ${opts.max}`);
+			return succeed$1(n);
+		},
+		...options
+	};
+	const initialValue = options.default === void 0 ? "" : `${opts.default}`;
+	const initialState = {
+		cursor: initialValue.length,
+		value: initialValue,
+		error: none()
+	};
+	return Custom(initialState, {
+		render: handleRenderInteger(opts),
+		process: handleProcessInteger(opts),
+		clear: handleNumberClear(opts)
+	});
+};
+/**
+* Transforms the output value produced by a prompt.
+*
+* @stability unstable
+* @category combinators
+* @since 4.0.0
+*/
+const map = /*#__PURE__*/ dual(2, (self, f) => flatMap(self, (a) => succeed(f(a))));
+/**
+* Creates a password prompt that masks typed input and returns the submitted
+* value wrapped in `Redacted`.
+*
+* @stability unstable
+* @category constructors
+* @since 4.0.0
+*/
+const Password = (options) => basePrompt(options, "password").pipe(map(make$1));
+/**
+* Runs a prompt by reading terminal input and rendering prompt frames until the
+* prompt submits a value.
+*
+* **Gotchas**
+*
+* The returned effect may fail with `Terminal.QuitError` if terminal input ends
+* or the prompt is quit.
+*
+* @stability unstable
+* @category running
+* @since 4.0.0
+*/
+const run = /*#__PURE__*/ fnUntraced(function* (self) {
+	const terminal = yield* Terminal;
+	const input = yield* cached(terminal.readInput);
+	return yield* runWithInput(self, terminal, input);
+}, /*#__PURE__*/ mapError(() => new QuitError({})), scoped);
+const getSelectInitialIndex = (choices) => {
+	let initialIndex = 0;
+	let seenSelected = -1;
+	for (let i = 0; i < choices.length; i++) if (choices[i].selected === true) {
+		if (seenSelected !== -1) throw new Error("InvalidArgumentException: only a single choice can be selected by default for Prompt.Select");
+		seenSelected = i;
+	}
+	if (seenSelected !== -1) initialIndex = seenSelected;
+	return initialIndex;
+};
+/**
+* Creates a prompt that lets the user select a single value from a list of
+* choices.
+*
+* **Gotchas**
+*
+* At most one choice may be marked as selected by default.
+*
+* @stability unstable
+* @category constructors
+* @since 4.0.0
+*/
+const Select = (options) => {
+	const opts = {
+		maxPerPage: 10,
+		...options
+	};
+	const initialIndex = getSelectInitialIndex(opts.choices);
+	return Custom(initialIndex, {
+		render: handleSelectRender(opts),
+		process: handleSelectProcess(opts),
+		clear: handleSelectClear(opts)
+	});
+};
+/**
+* Creates a `Prompt` which immediately succeeds with the specified value.
+*
+* **Details**
+*
+* This prompt does not attempt to obtain user input or render anything to the
+* screen.
+*
+* @stability unstable
+* @category constructors
+* @since 4.0.0
+*/
+const succeed = (value) => {
+	const op = Object.create(proto);
+	op._tag = "Succeed";
+	op.value = value;
+	return op;
+};
+/**
+* Creates a text-entry prompt that echoes input and returns the submitted
+* string after validation.
+*
+* @stability unstable
+* @category constructors
+* @since 4.0.0
+*/
+const String = (options) => basePrompt(options, "text");
+/**
+* Creates a toggle prompt that lets the user switch between active and inactive
+* states and returns the selected boolean value.
+*
+* @stability unstable
+* @category constructors
+* @since 4.0.0
+*/
+const Toggle = (options) => {
+	const opts = {
+		initial: false,
+		active: "on",
+		inactive: "off",
+		...options
+	};
+	return Custom(opts.initial, {
+		render: handleToggleRender(opts),
+		process: handleToggleProcess,
+		clear: () => handleToggleClear(opts)
+	});
+};
+const proto = {
+	.../*#__PURE__*/ Prototype({
+		label: "Prompt",
+		evaluate() {
+			return run(this);
+		}
+	}),
+	[TypeId]: { _Output: (_) => _ }
+};
+const runWithInput = (prompt, terminal, input) => suspend(() => {
+	const op = prompt;
+	switch (op._tag) {
+		case "Loop": return flatMap$1(input, (queue) => runLoop(op, terminal, queue));
+		case "OnSuccess": return flatMap$1(runWithInput(op.prompt, terminal, input), (a) => runWithInput(op.onSuccess(a), terminal, input));
+		case "Succeed": return succeed$1(op.value);
+	}
+});
+const runLoop = /*#__PURE__*/ fnUntraced(function* (loop, terminal, input) {
+	let state = isEffect(loop.initialState) ? yield* loop.initialState : loop.initialState;
+	let action = Action.NextFrame({ state });
+	let clear = "";
+	while (true) {
+		const msg = yield* loop.render(state, action);
+		yield* orDie(terminal.display(clear + msg));
+		clear = "";
+		if (loop.events) {
+			const takeInput = take(input).pipe(map$1((input) => ({
+				_tag: "Input",
+				input
+			})));
+			const result = yield* raceFirst(takeInput, take(loop.events).pipe(map$1((value) => ({
+				_tag: "Event",
+				value
+			}))));
+			action = yield* loop.process(result, state);
+		} else {
+			const result = yield* take(input);
+			action = yield* loop.process(result, state);
+		}
+		switch (action._tag) {
+			case "Beep": continue;
+			case "NextFrame":
+				clear = yield* loop.clear(state, action);
+				state = action.state;
+				continue;
+			case "Submit": {
+				clear = yield* loop.clear(state, action);
+				const msg = yield* loop.render(state, action);
+				yield* orDie(terminal.display(clear + msg));
+				return action.value;
+			}
+		}
+	}
+}, (effect, _, terminal) => ensuring(effect, orDie(terminal.display(cursorShow))));
+const Action = /*#__PURE__*/ taggedEnum();
+/**
+* Clears all lines taken up by the specified `text`.
+*/
+const eraseText = (text, columns) => {
+	if (columns === 0) return eraseLine + cursorTo(0);
+	let rows = 0;
+	const lines = text.split(NEWLINE_REGEXP);
+	for (const line of lines) rows += 1 + Math.floor(Math.max(line.length - 1, 0) / columns);
+	return eraseLines(rows);
+};
+const lines = (prompt, columns) => {
+	const lines = prompt.split(NEWLINE_REGEXP);
+	return columns === 0 ? lines.length : pipe(map$2(lines, (line) => Math.ceil(line.length / columns)), reduce(0, (left, right) => left + right));
+};
+const clearOutputWithError = (outputText, columns, errorText) => {
+	if (errorText !== void 0 && errorText.length > 0) return cursorDown(lines(errorText, columns)) + eraseText(`\n${errorText}`, columns) + eraseText(outputText, columns);
+	return eraseText(outputText, columns);
+};
+const renderBeep = "\x07";
+const NEWLINE_REGEXP = /\r?\n/;
+const handleConfirmClear = (options) => {
+	return fnUntraced(function* (state, _) {
+		const columns = yield* (yield* Terminal).columns;
+		const figures = yield* getTheme(options);
+		const confirmMessage = state.value ? options.placeholder.defaultConfirm : options.placeholder.defaultDeny;
+		const promptText = renderPrompt(confirmMessage, options.message, figures.prefix, figures.pointerSmall, figures, { plain: true });
+		return eraseText(promptText, columns) + (eraseLine + "\x1B[G");
+	});
+};
+const renderConfirmNextFrame = /*#__PURE__*/ fnUntraced(function* (state, options) {
+	const figures = yield* getTheme(options);
+	const leadingSymbol = annotateSymbol(figures, figures.prefix, figures.primaryColor);
+	const trailingSymbol = annotateSymbol(figures, figures.pointerSmall, figures.mutedColor);
+	const confirmMessage = state.value ? options.placeholder.defaultConfirm : options.placeholder.defaultDeny;
+	const confirm = annotate(figures.colors, confirmMessage, figures.mutedColor);
+	const promptMsg = renderPrompt(confirm, options.message, leadingSymbol, trailingSymbol, figures);
+	return cursorHide + promptMsg;
+});
+const renderConfirmSubmission = /*#__PURE__*/ fnUntraced(function* (value, options) {
+	const figures = yield* getTheme(options);
+	const leadingSymbol = annotateSymbol(figures, figures.tick, figures.successColor);
+	const trailingSymbol = annotateSymbol(figures, figures.ellipsis, figures.mutedColor);
+	const confirmMessage = value ? options.label.confirm : options.label.deny;
+	return renderPrompt(confirmMessage, options.message, leadingSymbol, trailingSymbol, figures) + "\n";
+});
+const handleConfirmRender = (options) => {
+	return (_, action) => {
+		return Action.$match(action, {
+			Beep: () => succeed$1(renderBeep),
+			NextFrame: ({ state }) => renderConfirmNextFrame(state, options),
+			Submit: ({ value }) => renderConfirmSubmission(value, options)
+		});
+	};
+};
+const TRUE_VALUE_REGEXP = /^y|t$/;
+const FALSE_VALUE_REGEXP = /^n|f$/;
+const handleConfirmProcess = (input, defaultValue) => {
+	const value = getOrElse(input.input, () => "");
+	if (input.key.name === "enter" || input.key.name === "return") return succeed$1(Action.Submit({ value: defaultValue }));
+	if (TRUE_VALUE_REGEXP.test(value.toLowerCase())) return succeed$1(Action.Submit({ value: true }));
+	if (FALSE_VALUE_REGEXP.test(value.toLowerCase())) return succeed$1(Action.Submit({ value: false }));
+	return succeed$1(Action.Beep());
+};
+const handleDateClear = (options) => {
+	return fnUntraced(function* (state, _) {
+		const columns = yield* (yield* Terminal).columns;
+		const figures = yield* getTheme(options);
+		const resetCurrentLine = eraseLine + "\x1B[G";
+		const parts = reduce(state.dateParts, "", (doc, part) => doc + part.toString());
+		const promptText = renderPrompt(parts, options.message, figures.prefix, figures.pointerSmall, figures, { plain: true });
+		const errorText = isSome(state.error) ? match$2(state.error.value.split(NEWLINE_REGEXP), {
+			onEmpty: () => "",
+			onNonEmpty: (errorLines) => separateSymbol(figures.pointerSmall, errorLines.join("\n"))
+		}) : "";
+		return clearOutputWithError(promptText, columns, errorText) + resetCurrentLine;
+	});
+};
+const renderDateError = (state, pointer, theme) => {
+	if (isSome(state.error)) {
+		const errorLines = state.error.value.split(NEWLINE_REGEXP);
+		if (isReadonlyArrayNonEmpty(errorLines)) {
+			const prefix = annotateSymbol(theme, pointer, theme.errorColor);
+			const lines = map$2(errorLines, (str) => annotateErrorLine(theme, str));
+			return "\x1B[s\n" + separateSymbol(prefix, lines.join("\n")) + "\x1B[u";
+		}
+	}
+	return "";
+};
+const renderParts = (state, theme, submitted = false) => {
+	return reduce(state.dateParts, "", (doc, part, currentIndex) => {
+		const partDoc = part.toString();
+		if (currentIndex === state.cursor && !submitted) {
+			const annotation = combine(underlined, theme.primaryColor);
+			return doc + annotate(theme.colors, partDoc, annotation);
+		}
+		return doc + partDoc;
+	});
+};
+const renderDateNextFrame = /*#__PURE__*/ fnUntraced(function* (state, options) {
+	const figures = yield* getTheme(options);
+	const leadingSymbol = annotateSymbol(figures, figures.prefix, figures.primaryColor);
+	const trailingSymbol = annotateSymbol(figures, figures.pointerSmall, figures.mutedColor);
+	const parts = renderParts(state, figures);
+	const promptMsg = renderPrompt(parts, options.message, leadingSymbol, trailingSymbol, figures);
+	const errorMsg = renderDateError(state, figures.pointerSmall, figures);
+	return cursorHide + promptMsg + errorMsg;
+});
+const renderDateSubmission = /*#__PURE__*/ fnUntraced(function* (state, options) {
+	const figures = yield* getTheme(options);
+	const leadingSymbol = annotateSymbol(figures, figures.tick, figures.successColor);
+	const trailingSymbol = annotateSymbol(figures, figures.ellipsis, figures.mutedColor);
+	const parts = renderParts(state, figures, true);
+	return renderPrompt(parts, options.message, leadingSymbol, trailingSymbol, figures) + "\n";
+});
+const processUp = (state) => {
+	state.dateParts[state.cursor].increment();
+	return Action.NextFrame({ state: {
+		...state,
+		typed: ""
+	} });
+};
+const processDown = (state) => {
+	state.dateParts[state.cursor].decrement();
+	return Action.NextFrame({ state: {
+		...state,
+		typed: ""
+	} });
+};
+const processDateCursorLeft = (state) => {
+	const previous = state.dateParts[state.cursor].previousPart();
+	if (isSome(previous)) return Action.NextFrame({ state: {
+		...state,
+		typed: "",
+		cursor: state.dateParts.indexOf(previous.value)
+	} });
+	return Action.Beep();
+};
+const processDateCursorRight = (state) => {
+	const next = state.dateParts[state.cursor].nextPart();
+	if (isSome(next)) return Action.NextFrame({ state: {
+		...state,
+		typed: "",
+		cursor: state.dateParts.indexOf(next.value)
+	} });
+	return Action.Beep();
+};
+const processDateNext = (state) => {
+	const next = state.dateParts[state.cursor].nextPart();
+	const cursor = match(next, {
+		onNone: () => state.dateParts.findIndex((part) => !part.isToken()),
+		onSome: (next) => state.dateParts.indexOf(next)
+	});
+	return Action.NextFrame({ state: {
+		...state,
+		typed: "",
+		cursor
+	} });
+};
+const defaultDateProcessor = (value, state) => {
+	if (/\d/.test(value)) {
+		const typed = state.typed + value;
+		state.dateParts[state.cursor].setValue(typed);
+		return Action.NextFrame({ state: {
+			...state,
+			typed
+		} });
+	}
+	return Action.Beep();
+};
+const defaultLocales = {
+	months: [
+		"January",
+		"February",
+		"March",
+		"April",
+		"May",
+		"June",
+		"July",
+		"August",
+		"September",
+		"October",
+		"November",
+		"December"
+	],
+	monthsShort: [
+		"Jan",
+		"Feb",
+		"Mar",
+		"Apr",
+		"May",
+		"Jun",
+		"Jul",
+		"Aug",
+		"Sep",
+		"Oct",
+		"Nov",
+		"Dec"
+	],
+	weekdays: [
+		"Sunday",
+		"Monday",
+		"Tuesday",
+		"Wednesday",
+		"Thursday",
+		"Friday",
+		"Saturday"
+	],
+	weekdaysShort: [
+		"Sun",
+		"Mon",
+		"Tue",
+		"Wed",
+		"Thu",
+		"Fri",
+		"Sat"
+	]
+};
+const handleDateRender = (options) => {
+	return (state, action) => {
+		return Action.$match(action, {
+			Beep: () => succeed$1(renderBeep),
+			NextFrame: ({ state }) => renderDateNextFrame(state, options),
+			Submit: () => renderDateSubmission(state, options)
+		});
+	};
+};
+const handleDateProcess = (options) => {
+	return (input, state) => {
+		switch (input.key.name) {
+			case "left": return succeed$1(processDateCursorLeft(state));
+			case "right": return succeed$1(processDateCursorRight(state));
+			case "k":
+			case "up": return succeed$1(processUp(state));
+			case "j":
+			case "down": return succeed$1(processDown(state));
+			case "tab": return succeed$1(processDateNext(state));
+			case "enter":
+			case "return": return match$1(options.validate(state.value), {
+				onFailure: (error) => Action.NextFrame({ state: {
+					...state,
+					error: some(error)
+				} }),
+				onSuccess: (value) => Action.Submit({ value })
+			});
+			default: return succeed$1(defaultDateProcessor(getOrElse(input.input, () => ""), state));
+		}
+	};
+};
+const DATE_PART_REGEXP = /\\(.)|"((?:\\["\\]|[^"])+)"|(D[Do]?|d{3,4}|d)|(M{1,4})|(YY(?:YY)?)|([aA])|([Hh]{1,2})|(m{1,2})|(s{1,2})|(S{1,4})|./g;
+const regExpGroups = {
+	1: ({ token, ...opts }) => new Token({
+		token: token.replace(/\\(.)/g, "$1"),
+		...opts
+	}),
+	2: (opts) => new Day(opts),
+	3: (opts) => new Month(opts),
+	4: (opts) => new Year(opts),
+	5: (opts) => new Meridiem(opts),
+	6: (opts) => new Hours(opts),
+	7: (opts) => new Minutes(opts),
+	8: (opts) => new Seconds(opts),
+	9: (opts) => new Milliseconds(opts)
+};
+const makeDateParts = (dateMask, date, locales) => {
+	const parts = [];
+	let result = null;
+	while (result = DATE_PART_REGEXP.exec(dateMask)) {
+		const match = result.shift();
+		const index = result.findIndex((group) => group !== void 0);
+		if (index in regExpGroups) {
+			const token = result[index] || match;
+			parts.push(regExpGroups[index]({
+				token,
+				date,
+				parts,
+				locales
+			}));
+		} else parts.push(new Token({
+			token: result[index] || match,
+			date,
+			parts,
+			locales
+		}));
+	}
+	const orderedParts = parts.reduce((array, element) => {
+		const lastElement = array[array.length - 1];
+		if (element.isToken() && lastElement !== void 0 && lastElement.isToken()) lastElement.setValue(element.token);
+		else array.push(element);
+		return array;
+	}, empty());
+	parts.splice(0, parts.length, ...orderedParts);
+	return parts;
+};
+var DatePart = class {
+	token;
+	date;
+	parts;
+	locales;
+	constructor(params) {
+		this.token = params.token;
+		this.locales = params.locales;
+		this.date = params.date || new globalThis.Date();
+		this.parts = params.parts || [this];
+	}
+	/**
+	* Returns `true` if this `DatePart` is a `Token`, `false` otherwise.
+	*/
+	isToken() {
+		return false;
+	}
+	/**
+	* Retrieves the next date part in the list of parts.
+	*/
+	nextPart() {
+		const currentPartIndex = getOrElse(findFirstIndex(this.parts, (part) => part === this), () => 0);
+		return findFirst(this.parts.slice(currentPartIndex + 1), (part) => !part.isToken());
+	}
+	/**
+	* Retrieves the previous date part in the list of parts.
+	*/
+	previousPart() {
+		const currentPartIndex = findFirstIndex(this.parts, (part) => part === this);
+		if (isSome(currentPartIndex)) return findLast(this.parts.slice(0, currentPartIndex.value), (part) => !part.isToken());
+		return none();
+	}
+	toString() {
+		return globalThis.String(this.date);
+	}
+};
+var Token = class extends DatePart {
+	increment() {}
+	decrement() {}
+	setValue(value) {
+		this.token = this.token + value;
+	}
+	isToken() {
+		return true;
+	}
+	toString() {
+		return this.token;
+	}
+};
+var Milliseconds = class extends DatePart {
+	increment() {
+		this.date.setMilliseconds(this.date.getMilliseconds() + 1);
+	}
+	decrement() {
+		this.date.setMilliseconds(this.date.getMilliseconds() - 1);
+	}
+	setValue(value) {
+		this.date.setMilliseconds(globalThis.Number.parseInt(value.slice(-this.token.length)));
+	}
+	toString() {
+		return `${this.date.getMilliseconds()}`.padStart(4, "0").substring(0, this.token.length);
+	}
+};
+var Seconds = class extends DatePart {
+	increment() {
+		this.date.setSeconds(this.date.getSeconds() + 1);
+	}
+	decrement() {
+		this.date.setSeconds(this.date.getSeconds() - 1);
+	}
+	setValue(value) {
+		this.date.setSeconds(globalThis.Number.parseInt(value.slice(-2)));
+	}
+	toString() {
+		const seconds = `${this.date.getSeconds()}`;
+		return this.token.length > 1 ? seconds.padStart(2, "0") : seconds;
+	}
+};
+var Minutes = class extends DatePart {
+	increment() {
+		this.date.setMinutes(this.date.getMinutes() + 1);
+	}
+	decrement() {
+		this.date.setMinutes(this.date.getMinutes() - 1);
+	}
+	setValue(value) {
+		this.date.setMinutes(globalThis.Number.parseInt(value.slice(-2)));
+	}
+	toString() {
+		const minutes = `${this.date.getMinutes()}`;
+		return this.token.length > 1 ? minutes.padStart(2, "0") : minutes;
+	}
+};
+var Hours = class extends DatePart {
+	increment() {
+		this.date.setHours(this.date.getHours() + 1);
+	}
+	decrement() {
+		this.date.setHours(this.date.getHours() - 1);
+	}
+	setValue(value) {
+		this.date.setHours(globalThis.Number.parseInt(value.slice(-2)));
+	}
+	toString() {
+		const hours = /h/.test(this.token) ? this.date.getHours() % 12 || 12 : this.date.getHours();
+		return this.token.length > 1 ? `${hours}`.padStart(2, "0") : `${hours}`;
+	}
+};
+var Day = class extends DatePart {
+	increment() {
+		this.date.setDate(this.date.getDate() + 1);
+	}
+	decrement() {
+		this.date.setDate(this.date.getDate() - 1);
+	}
+	setValue(value) {
+		this.date.setDate(globalThis.Number.parseInt(value.slice(-2)));
+	}
+	toString() {
+		const date = this.date.getDate();
+		const day = this.date.getDay();
+		switch (this.token) {
+			case "DD": return `${date}`.padStart(2, "0");
+			case "Do": return `${date}${this.ordinalIndicator(date)}`;
+			case "d": return `${day + 1}`;
+			case "ddd": return this.locales.weekdaysShort[day];
+			case "dddd": return this.locales.weekdays[day];
+			default: return `${date}`;
+		}
+	}
+	ordinalIndicator(day) {
+		if (day >= 11 && day <= 13) return "th";
+		switch (day % 10) {
+			case 1: return "st";
+			case 2: return "nd";
+			case 3: return "rd";
+			default: return "th";
+		}
+	}
+};
+var Month = class extends DatePart {
+	increment() {
+		this.date.setMonth(this.date.getMonth() + 1);
+	}
+	decrement() {
+		this.date.setMonth(this.date.getMonth() - 1);
+	}
+	setValue(value) {
+		const month = globalThis.Number.parseInt(value.slice(-2)) - 1;
+		this.date.setMonth(month < 0 ? 0 : month);
+	}
+	toString() {
+		const month = this.date.getMonth();
+		switch (this.token.length) {
+			case 2: return `${month + 1}`.padStart(2, "0");
+			case 3: return this.locales.monthsShort[month];
+			case 4: return this.locales.months[month];
+			default: return `${month + 1}`;
+		}
+	}
+};
+var Year = class extends DatePart {
+	increment() {
+		this.date.setFullYear(this.date.getFullYear() + 1);
+	}
+	decrement() {
+		this.date.setFullYear(this.date.getFullYear() - 1);
+	}
+	setValue(value) {
+		this.date.setFullYear(globalThis.Number.parseInt(value.slice(-4)));
+	}
+	toString() {
+		const year = `${this.date.getFullYear()}`.padStart(4, "0");
+		return this.token.length === 2 ? year.slice(-2) : year;
+	}
+};
+var Meridiem = class extends DatePart {
+	increment() {
+		this.date.setHours((this.date.getHours() + 12) % 24);
+	}
+	decrement() {
+		this.increment();
+	}
+	setValue(_value) {}
+	toString() {
+		const meridiem = this.date.getHours() >= 12 ? "pm" : "am";
+		return /A/.test(this.token) ? meridiem.toUpperCase() : meridiem;
+	}
+};
+const renderPrompt = (confirm, message, leadingSymbol, trailingSymbol, theme, options) => {
+	const prefix = leadingSymbol.length === 0 ? "" : leadingSymbol + " ";
+	const renderLine = (line) => {
+		let output = prefix + line;
+		if (trailingSymbol.length > 0) output += " " + trailingSymbol;
+		if (confirm.length > 0) output += " " + confirm;
+		else if (trailingSymbol.length > 0) output += " ";
+		return output;
+	};
+	return match$2(message.split(NEWLINE_REGEXP), {
+		onEmpty: () => renderLine(""),
+		onNonEmpty: (promptLines) => {
+			const lines = options?.plain === true ? promptLines : map$2(promptLines, (line) => annotate(theme.colors, line, bold));
+			return renderLine(lines.join("\n"));
+		}
+	});
+};
+const renderChoiceDescription = (choice, isActive, theme, renderOptions) => {
+	if (!choice.disabled && choice.description && isActive) {
+		const text = theme.descriptionSeparator + choice.description;
+		return renderOptions?.plain === true ? text : annotate(theme.colors, text, theme.mutedColor);
+	}
+	return "";
+};
+const handleNumberClear = (options) => {
+	return fnUntraced(function* (state, _) {
+		const columns = yield* (yield* Terminal).columns;
+		const figures = yield* getTheme(options);
+		const resetCurrentLine = eraseLine + "\x1B[G";
+		const errorText = renderNumberError(state, figures.pointerSmall, figures, { plain: true });
+		const promptText = renderNumberOutput(state, figures.prefix, figures.pointerSmall, options, figures, { plain: true });
+		return clearOutputWithError(promptText, columns, errorText) + resetCurrentLine;
+	});
+};
+const renderNumberInput = (state, submitted, theme, renderOptions) => {
+	const value = state.value === "" ? "" : `${state.value}`;
+	if (submitted || renderOptions?.plain === true) return value;
+	const annotation = isSome(state.error) ? theme.errorColor : combine(underlined, theme.primaryColor);
+	return annotate(theme.colors, value, annotation);
+};
+const renderNumberError = (state, pointer, theme, renderOptions) => {
+	if (isSome(state.error)) return match$2(state.error.value.split(NEWLINE_REGEXP), {
+		onEmpty: () => "",
+		onNonEmpty: (errorLines) => {
+			if (renderOptions?.plain === true) return separateSymbol(pointer, errorLines.join("\n"));
+			const prefix = annotateSymbol(theme, pointer, theme.errorColor);
+			const lines = map$2(errorLines, (str) => annotateErrorLine(theme, str));
+			return "\x1B[s\n" + separateSymbol(prefix, lines.join("\n")) + "\x1B[u";
+		}
+	});
+	return "";
+};
+const renderNumberOutput = (state, leadingSymbol, trailingSymbol, options, theme, renderOptions, submitted = false) => {
+	const value = renderNumberInput(state, submitted, theme, renderOptions);
+	return renderPrompt(value, options.message, leadingSymbol, trailingSymbol, theme, renderOptions);
+};
+const renderNumberNextFrame = /*#__PURE__*/ fnUntraced(function* (state, options) {
+	const figures = yield* getTheme(options);
+	const leadingSymbol = annotateSymbol(figures, figures.prefix, figures.primaryColor);
+	const trailingSymbol = annotateSymbol(figures, figures.pointerSmall, figures.mutedColor);
+	const errorMsg = renderNumberError(state, figures.pointerSmall, figures);
+	return renderNumberOutput(state, leadingSymbol, trailingSymbol, options, figures) + errorMsg;
+});
+const renderNumberSubmission = /*#__PURE__*/ fnUntraced(function* (nextState, options) {
+	const figures = yield* getTheme(options);
+	const leadingSymbol = annotateSymbol(figures, figures.tick, figures.successColor);
+	const trailingSymbol = annotateSymbol(figures, figures.ellipsis, figures.mutedColor);
+	return renderNumberOutput(nextState, leadingSymbol, trailingSymbol, options, figures, void 0, true) + "\n";
+});
+const processNumberBackspace = (state) => {
+	if (state.value.length <= 0) return succeed$1(Action.Beep());
+	const value = state.value.slice(0, state.value.length - 1);
+	return succeed$1(Action.NextFrame({ state: {
+		...state,
+		value,
+		error: none()
+	} }));
+};
+const processNumberClear = (state) => succeed$1(Action.NextFrame({ state: {
+	...state,
+	cursor: 0,
+	value: "",
+	error: none()
+} }));
+const defaultIntProcessor = (input, state) => {
+	if (state.value.length === 0 && input === "-") return succeed$1(Action.NextFrame({ state: {
+		...state,
+		value: "-",
+		error: none()
+	} }));
+	const parsed = globalThis.Number.parseInt(state.value + input);
+	if (globalThis.Number.isNaN(parsed)) return succeed$1(Action.Beep());
+	else return succeed$1(Action.NextFrame({ state: {
+		...state,
+		value: `${parsed}`,
+		error: none()
+	} }));
+};
+const defaultFloatProcessor = (input, state) => {
+	if (input === "." && state.value.includes(".")) return succeed$1(Action.Beep());
+	if (state.value.length === 0 && input === "-") return succeed$1(Action.NextFrame({ state: {
+		...state,
+		value: "-",
+		error: none()
+	} }));
+	const parsed = globalThis.Number.parseFloat(state.value + input);
+	if (globalThis.Number.isNaN(parsed)) return succeed$1(Action.Beep());
+	else return succeed$1(Action.NextFrame({ state: {
+		...state,
+		value: input === "." ? `${parsed}.` : state.value.includes(".") && /^\d$/.test(input) ? state.value + input : `${parsed}`,
+		error: none()
+	} }));
+};
+const handleRenderInteger = (options) => {
+	return (state, action) => {
+		return Action.$match(action, {
+			Beep: () => succeed$1(renderBeep),
+			NextFrame: ({ state }) => renderNumberNextFrame(state, options),
+			Submit: () => renderNumberSubmission(state, options)
+		});
+	};
+};
+const handleProcessInteger = (options) => {
+	return (input, state) => {
+		if (input.key.ctrl && input.key.name === "u") return processNumberClear(state);
+		switch (input.key.name) {
+			case "backspace": return processNumberBackspace(state);
+			case "k":
+			case "up": return succeed$1(Action.NextFrame({ state: {
+				...state,
+				value: state.value === "" || state.value === "-" ? `${options.incrementBy}` : `${globalThis.Number.parseInt(state.value) + options.incrementBy}`,
+				error: none()
+			} }));
+			case "j":
+			case "down": return succeed$1(Action.NextFrame({ state: {
+				...state,
+				value: state.value === "" || state.value === "-" ? `-${options.decrementBy}` : `${globalThis.Number.parseInt(state.value) - options.decrementBy}`,
+				error: none()
+			} }));
+			case "enter":
+			case "return": {
+				const parsed = globalThis.Number.parseInt(state.value);
+				if (globalThis.Number.isNaN(parsed)) return succeed$1(Action.NextFrame({ state: {
+					...state,
+					error: some("Must provide an integer value")
+				} }));
+				else return match$1(options.validate(parsed), {
+					onFailure: (error) => Action.NextFrame({ state: {
+						...state,
+						error: some(error)
+					} }),
+					onSuccess: (value) => Action.Submit({ value })
+				});
+			}
+			default: return defaultIntProcessor(getOrElse(input.input, () => ""), state);
+		}
+	};
+};
+const handleRenderFloat = (options) => {
+	return (state, action) => {
+		return Action.$match(action, {
+			Beep: () => succeed$1(renderBeep),
+			NextFrame: ({ state }) => renderNumberNextFrame(state, options),
+			Submit: () => renderNumberSubmission(state, options)
+		});
+	};
+};
+const handleProcessFloat = (options) => {
+	return (input, state) => {
+		if (input.key.ctrl && input.key.name === "u") return processNumberClear(state);
+		switch (input.key.name) {
+			case "backspace": return processNumberBackspace(state);
+			case "k":
+			case "up": return succeed$1(Action.NextFrame({ state: {
+				...state,
+				value: state.value === "" || state.value === "-" ? `${options.incrementBy}` : `${globalThis.Number.parseFloat(state.value) + options.incrementBy}`,
+				error: none()
+			} }));
+			case "j":
+			case "down": return succeed$1(Action.NextFrame({ state: {
+				...state,
+				value: state.value === "" || state.value === "-" ? `-${options.decrementBy}` : `${globalThis.Number.parseFloat(state.value) - options.decrementBy}`,
+				error: none()
+			} }));
+			case "enter":
+			case "return": {
+				const parsed = globalThis.Number.parseFloat(state.value);
+				if (globalThis.Number.isNaN(parsed)) return succeed$1(Action.NextFrame({ state: {
+					...state,
+					error: some("Must provide a floating point value")
+				} }));
+				else return flatMap$1(sync(() => round(parsed, options.precision)), (rounded) => match$1(options.validate(rounded), {
+					onFailure: (error) => Action.NextFrame({ state: {
+						...state,
+						error: some(error)
+					} }),
+					onSuccess: (value) => Action.Submit({ value })
+				}));
+			}
+			default: return defaultFloatProcessor(getOrElse(input.input, () => ""), state);
+		}
+	};
+};
+const renderSelectOutput = (leadingSymbol, trailingSymbol, options, theme, renderOptions) => options.message === void 0 ? void 0 : renderPrompt("", options.message, leadingSymbol, trailingSymbol, theme, renderOptions);
+const withSelectHeader = (header, body) => header === void 0 ? body : header + "\n" + body;
+const renderChoicePrefix = (state, choices, toDisplay, currentIndex, figures, renderOptions) => {
+	const prefix = renderPagingPrefix(figures, currentIndex === toDisplay.startIndex && toDisplay.startIndex > 0, currentIndex === toDisplay.endIndex - 1 && toDisplay.endIndex < choices.length);
+	if (renderOptions?.plain === true) return state === currentIndex ? figures.pointer + prefix : prefix + " ".repeat(figures.pointer.length);
+	if (choices[currentIndex].disabled) {
+		const annotation = combine(bold, figures.mutedColor);
+		return state === currentIndex ? annotateSymbol(figures, figures.pointer, annotation) + prefix : prefix + " ".repeat(figures.pointer.length);
+	}
+	return state === currentIndex ? annotateSymbol(figures, figures.pointer, figures.primaryColor) + prefix : prefix + " ".repeat(figures.pointer.length);
+};
+const renderChoiceTitle = (choice, isSelected, theme, renderOptions) => {
+	if (renderOptions?.plain === true) return choice.title;
+	const title = choice.title;
+	if (isSelected) return choice.disabled ? annotate(theme.colors, title, combine(underlined, theme.mutedColor)) : annotate(theme.colors, title, combine(underlined, theme.primaryColor));
+	return choice.disabled ? annotate(theme.colors, title, combine(strikethrough, theme.mutedColor)) : title;
+};
+const renderSelectChoices = (state, options, figures, renderOptions) => {
+	const choices = options.choices;
+	const toDisplay = entriesToDisplay(state, choices.length, options.maxPerPage);
+	const documents = [];
+	for (let index = toDisplay.startIndex; index < toDisplay.endIndex; index++) {
+		const choice = choices[index];
+		const isSelected = state === index;
+		const prefix = renderChoicePrefix(state, choices, toDisplay, index, figures, renderOptions);
+		const title = renderChoiceTitle(choice, isSelected, figures, renderOptions);
+		const description = renderChoiceDescription(choice, isSelected, figures, renderOptions);
+		documents.push(prefix + title + " " + description);
+	}
+	return documents.join("\n");
+};
+const renderSelectNextFrame = /*#__PURE__*/ fnUntraced(function* (state, options) {
+	const figures = yield* getTheme(options);
+	const choices = renderSelectChoices(state, options, figures);
+	const leadingSymbol = annotateSymbol(figures, figures.prefix, figures.primaryColor);
+	const trailingSymbol = annotateSymbol(figures, figures.pointerSmall, figures.mutedColor);
+	const promptMsg = renderSelectOutput(leadingSymbol, trailingSymbol, options, figures);
+	return cursorHide + withSelectHeader(promptMsg, choices);
+});
+const renderSelectSubmission = /*#__PURE__*/ fnUntraced(function* (state, options) {
+	const figures = yield* getTheme(options);
+	const selected = options.choices[state].title;
+	const leadingSymbol = annotateSymbol(figures, figures.tick, figures.successColor);
+	const trailingSymbol = annotateSymbol(figures, figures.ellipsis, figures.mutedColor);
+	return (renderSelectOutput(leadingSymbol, trailingSymbol, options, figures) ?? leadingSymbol) + " " + annotate(figures.colors, selected, figures.submittedColor) + "\n";
+});
+const processSelectCursorUp = (state, choices) => {
+	if (state === 0) return succeed$1(Action.NextFrame({ state: choices.length - 1 }));
+	return succeed$1(Action.NextFrame({ state: state - 1 }));
+};
+const processSelectCursorDown = (state, choices) => {
+	if (state === choices.length - 1) return succeed$1(Action.NextFrame({ state: 0 }));
+	return succeed$1(Action.NextFrame({ state: state + 1 }));
+};
+const processSelectNext = (state, choices) => {
+	return succeed$1(Action.NextFrame({ state: (state + 1) % choices.length }));
+};
+const handleSelectRender = (options) => {
+	return (state, action) => {
+		return Action.$match(action, {
+			Beep: () => succeed$1(renderBeep),
+			NextFrame: ({ state }) => renderSelectNextFrame(state, options),
+			Submit: () => renderSelectSubmission(state, options)
+		});
+	};
+};
+const handleSelectClear = (options) => fnUntraced(function* (state, _) {
+	const columns = yield* (yield* Terminal).columns;
+	const figures = yield* getTheme(options);
+	const clearPrompt = eraseLine + "\x1B[G";
+	const promptText = renderSelectOutput(figures.prefix, figures.pointerSmall, options, figures, { plain: true });
+	const choicesText = renderSelectChoices(state, options, figures, { plain: true });
+	return eraseText(withSelectHeader(promptText, choicesText), columns) + clearPrompt;
+});
+const handleSelectProcess = (options) => {
+	return (input, state) => {
+		switch (input.key.name) {
+			case "k":
+			case "up": return processSelectCursorUp(state, options.choices);
+			case "j":
+			case "down": return processSelectCursorDown(state, options.choices);
+			case "tab": return processSelectNext(state, options.choices);
+			case "enter":
+			case "return": {
+				const selected = options.choices[state];
+				if (selected.disabled) return succeed$1(Action.Beep());
+				return succeed$1(Action.Submit({ value: selected.value }));
+			}
+			default: return succeed$1(Action.Beep());
+		}
+	};
+};
+const renderClearScreen = /*#__PURE__*/ fnUntraced(function* (state, options) {
+	const columns = yield* (yield* Terminal).columns;
+	const figures = yield* getTheme(options);
+	const resetCurrentLine = eraseLine + "\x1B[G";
+	const errorText = renderTextError(state, figures.pointerSmall, figures, { plain: true });
+	return clearOutputWithError(renderTextOutput(state, figures.prefix, figures.pointerSmall, options, figures, { plain: true }), columns, errorText) + resetCurrentLine;
+});
+const renderTextInput = (nextState, options, theme, submitted, renderOptions) => {
+	const text = nextState.value;
+	if (renderOptions?.plain === true) switch (options.type) {
+		case "hidden": return "";
+		case "password": return theme.passwordMask.repeat(text.length);
+		case "text": return text;
+	}
+	if (text.length === 0) return "";
+	const annotation = isSome(nextState.error) ? theme.errorColor : submitted ? theme.submittedColor : combine(underlined, theme.primaryColor);
+	switch (options.type) {
+		case "hidden": return "";
+		case "password": return annotateSymbol(theme, theme.passwordMask.repeat(text.length), annotation);
+		case "text": return annotate(theme.colors, text, annotation);
+	}
+};
+const renderTextError = (nextState, pointer, theme, renderOptions) => {
+	if (isSome(nextState.error)) return match$2(nextState.error.value.split(NEWLINE_REGEXP), {
+		onEmpty: () => "",
+		onNonEmpty: (errorLines) => {
+			if (renderOptions?.plain === true) return separateSymbol(pointer, errorLines.join("\n"));
+			const prefix = annotateSymbol(theme, pointer, theme.errorColor);
+			const lines = map$2(errorLines, (str) => annotateErrorLine(theme, str));
+			return "\x1B[s\n" + separateSymbol(prefix, lines.join("\n")) + "\x1B[u";
+		}
+	});
+	return "";
+};
+const renderTextOutput = (nextState, leadingSymbol, trailingSymbol, options, theme, renderOptions, submitted = false) => {
+	const value = renderTextInput(nextState, options, theme, submitted, renderOptions);
+	return renderPrompt(value, options.message, leadingSymbol, trailingSymbol, theme, renderOptions);
+};
+const renderTextNextFrame = /*#__PURE__*/ fnUntraced(function* (state, options) {
+	const figures = yield* getTheme(options);
+	const leadingSymbol = annotateSymbol(figures, figures.prefix, figures.primaryColor);
+	const trailingSymbol = annotateSymbol(figures, figures.pointerSmall, figures.mutedColor);
+	const promptMsg = renderTextOutput(state, leadingSymbol, trailingSymbol, options, figures);
+	const errorMsg = renderTextError(state, figures.pointerSmall, figures);
+	const cursorWidth = options.type === "password" ? figures.passwordMask.length : 1;
+	const offset = (state.cursor - state.value.length) * cursorWidth;
+	return promptMsg + errorMsg + cursorMove(offset);
+});
+const renderTextSubmission = /*#__PURE__*/ fnUntraced(function* (state, options) {
+	const figures = yield* getTheme(options);
+	const leadingSymbol = annotateSymbol(figures, figures.tick, figures.successColor);
+	const trailingSymbol = annotateSymbol(figures, figures.ellipsis, figures.mutedColor);
+	return renderTextOutput(state, leadingSymbol, trailingSymbol, options, figures, void 0, true) + "\n";
+});
+const processTextBackspace = (state) => {
+	if (state.cursor <= 0) return succeed$1(Action.Beep());
+	const beforeCursor = state.value.slice(0, state.cursor - 1);
+	const afterCursor = state.value.slice(state.cursor);
+	const cursor = state.cursor - 1;
+	const value = `${beforeCursor}${afterCursor}`;
+	return succeed$1(Action.NextFrame({ state: {
+		...state,
+		cursor,
+		value,
+		error: none()
+	} }));
+};
+const processTextClear = (state) => succeed$1(Action.NextFrame({ state: {
+	...state,
+	cursor: 0,
+	value: "",
+	error: none()
+} }));
+const processTextCursorLeft = (state) => {
+	if (state.cursor <= 0) return succeed$1(Action.Beep());
+	const cursor = state.cursor - 1;
+	return succeed$1(Action.NextFrame({ state: {
+		...state,
+		cursor,
+		error: none()
+	} }));
+};
+const processTextCursorRight = (state) => {
+	if (state.cursor >= state.value.length) return succeed$1(Action.Beep());
+	const cursor = Math.min(state.cursor + 1, state.value.length);
+	return succeed$1(Action.NextFrame({ state: {
+		...state,
+		cursor,
+		error: none()
+	} }));
+};
+const processTextCursorStart = (state) => succeed$1(Action.NextFrame({ state: {
+	...state,
+	cursor: 0,
+	error: none()
+} }));
+const processTextCursorEnd = (state) => succeed$1(Action.NextFrame({ state: {
+	...state,
+	cursor: state.value.length,
+	error: none()
+} }));
+const processTab = (state, options) => {
+	if (state.value === options.default) return succeed$1(Action.Beep());
+	const value = state.value.length === 0 ? options.default : state.value;
+	return succeed$1(Action.NextFrame({ state: {
+		...state,
+		value,
+		cursor: value.length,
+		error: none()
+	} }));
+};
+const defaultTextProcessor = (input, state) => {
+	const value = `${state.value.slice(0, state.cursor)}${input}${state.value.slice(state.cursor)}`;
+	const cursor = state.cursor + input.length;
+	return succeed$1(Action.NextFrame({ state: {
+		...state,
+		cursor,
+		value,
+		error: none()
+	} }));
+};
+const handleTextRender = (options) => {
+	return (state, action) => {
+		return Action.$match(action, {
+			Beep: () => succeed$1(renderBeep),
+			NextFrame: ({ state }) => renderTextNextFrame(state, options),
+			Submit: () => renderTextSubmission(state, options)
+		});
+	};
+};
+const handleTextProcess = (options) => {
+	return (input, state) => {
+		if (input.key.ctrl) switch (input.key.name) {
+			case "u": return processTextClear(state);
+			case "a": return processTextCursorStart(state);
+			case "e": return processTextCursorEnd(state);
+			default: return succeed$1(Action.Beep());
+		}
+		switch (input.key.name) {
+			case "backspace": return processTextBackspace(state);
+			case "left": return processTextCursorLeft(state);
+			case "right": return processTextCursorRight(state);
+			case "home": return processTextCursorStart(state);
+			case "end": return processTextCursorEnd(state);
+			case "enter":
+			case "return": {
+				const value = state.value;
+				return match$1(options.validate(value), {
+					onFailure: (error) => Action.NextFrame({ state: {
+						...state,
+						value,
+						error: some(error)
+					} }),
+					onSuccess: (value) => Action.Submit({ value })
+				});
+			}
+			case "tab": return processTab(state, options);
+			default: return defaultTextProcessor(getOrElse(input.input, () => ""), state);
+		}
+	};
+};
+const handleTextClear = (options) => {
+	return (state, _) => {
+		return renderClearScreen(state, options);
+	};
+};
+const basePrompt = (options, type) => {
+	const opts = {
+		default: "",
+		type,
+		validate: succeed$1,
+		...options
+	};
+	const initialState = {
+		cursor: opts.default.length,
+		value: opts.default,
+		error: none()
+	};
+	return Custom(initialState, {
+		render: handleTextRender(opts),
+		process: handleTextProcess(opts),
+		clear: handleTextClear(opts)
+	});
+};
+const handleToggleClear = /*#__PURE__*/ fnUntraced(function* (options) {
+	const columns = yield* (yield* Terminal).columns;
+	const figures = yield* getTheme(options);
+	const clearPrompt = eraseLine + "\x1B[G";
+	const toggleText = options.active + " " + separateSymbol(figures.toggleSeparator, options.inactive);
+	const promptText = renderPrompt(toggleText, options.message, figures.prefix, figures.pointerSmall, figures, { plain: true });
+	return eraseText(promptText, columns) + clearPrompt;
+});
+const renderToggle = (value, options, theme, submitted = false) => {
+	const separator = annotateSymbol(theme, theme.toggleSeparator, theme.mutedColor);
+	const selectedAnnotation = combine(underlined, submitted ? theme.submittedColor : theme.primaryColor);
+	const inactive = value ? options.inactive : annotate(theme.colors, options.inactive, selectedAnnotation);
+	return (value ? annotate(theme.colors, options.active, selectedAnnotation) : options.active) + " " + separateSymbol(separator, inactive);
+};
+const renderToggleNextFrame = /*#__PURE__*/ fnUntraced(function* (state, options) {
+	const figures = yield* getTheme(options);
+	const leadingSymbol = annotateSymbol(figures, figures.prefix, figures.primaryColor);
+	const trailingSymbol = annotateSymbol(figures, figures.pointerSmall, figures.mutedColor);
+	const toggle = renderToggle(state, options, figures);
+	const promptMsg = renderPrompt(toggle, options.message, leadingSymbol, trailingSymbol, figures);
+	return cursorHide + promptMsg;
+});
+const renderToggleSubmission = /*#__PURE__*/ fnUntraced(function* (value, options) {
+	const figures = yield* getTheme(options);
+	const leadingSymbol = annotateSymbol(figures, figures.tick, figures.successColor);
+	const trailingSymbol = annotateSymbol(figures, figures.ellipsis, figures.mutedColor);
+	const toggle = renderToggle(value, options, figures, true);
+	return renderPrompt(toggle, options.message, leadingSymbol, trailingSymbol, figures) + "\n";
+});
+const activate = /*#__PURE__*/ succeed$1(/*#__PURE__*/ Action.NextFrame({ state: true }));
+const deactivate = /*#__PURE__*/ succeed$1(/*#__PURE__*/ Action.NextFrame({ state: false }));
+const handleToggleRender = (options) => {
+	return (state, action) => {
+		switch (action._tag) {
+			case "Beep": return succeed$1(renderBeep);
+			case "NextFrame": return renderToggleNextFrame(state, options);
+			case "Submit": return renderToggleSubmission(state, options);
+		}
+	};
+};
+const handleToggleProcess = (input, state) => {
+	switch (input.key.name) {
+		case "0":
+		case "j":
+		case "delete":
+		case "right":
+		case "down": return deactivate;
+		case "1":
+		case "k":
+		case "left":
+		case "up": return activate;
+		case " ":
+		case "tab": return state ? deactivate : activate;
+		case "enter":
+		case "return": return succeed$1(Action.Submit({ value: state }));
+		default: return succeed$1(Action.Beep());
+	}
+};
+const entriesToDisplay = (cursor, total, maxVisible) => {
+	const max = maxVisible === void 0 ? total : maxVisible;
+	let startIndex = Math.min(total - max, cursor - Math.floor(max / 2));
+	if (startIndex < 0) startIndex = 0;
+	const endIndex = Math.min(startIndex + max, total);
+	return {
+		startIndex,
+		endIndex
+	};
+};
+// ../../node_modules/.pnpm/effect@4.1.2_patch_hash=0e61176203bb1256381ce1c5b488d7951983ce38ff698647d3f4617383abbf07/node_modules/effect/dist/cli/TerminalCapabilities.js
+/**
+* Reference to the terminal capabilities of the current process.
+*
+* **When to use**
+*
+* Use when application output should share the built-in help, version, and
+* error output's answer. Provide `layer` to detect through
+* `ConfigProvider` and `Stdio`, or provide a value to override detection.
+*
+* **Details**
+*
+* The default is detected from the current process the first time it is
+* read, so later changes to the environment do not affect it. Without a
+* `process` global, every flag is `false`.
+*
+* @stability unstable
+* @category services
+* @since 4.0.0
+*/
+const TerminalCapabilities = /*#__PURE__*/ Reference("effect/cli/TerminalCapabilities", { defaultValue: () => fromProcess() });
+const isPresent = (value) => value !== void 0 && value.length > 0;
+const isForcingColor = (value) => isPresent(value) && value !== "0" && value.toLowerCase() !== "false";
+const detect = (input) => {
+	if (input.term === "dumb") return {
+		canColor: false,
+		canAnimate: false,
+		canPrompt: false
+	};
+	return {
+		canColor: !isPresent(input.noColor) && (isForcingColor(input.forceColor) || input.stdoutIsTerminal),
+		canAnimate: input.stdoutIsTerminal,
+		canPrompt: input.stdinIsTerminal && input.stdoutIsTerminal
+	};
+};
+const fromProcess = () => {
+	const process = globalThis.process;
+	return detect({
+		noColor: process?.env?.NO_COLOR,
+		forceColor: process?.env?.FORCE_COLOR,
+		term: process?.env?.TERM,
+		stdinIsTerminal: process?.stdin?.isTTY === true,
+		stdoutIsTerminal: process?.stdout?.isTTY === true
+	});
+};
+export { isQuitError as C, Terminal as S, green as _, Number as a, white as b, String as c, run as d, annotate as f, detectColors as g, cyanBright as h, Int as i, Theme as l, bold as m, Confirm as n, Password as o, blackBright as p, Date as r, Select as s, TerminalCapabilities as t, Toggle as u, magenta as v, make as w, QuitError as x, red as y };