semola 0.5.0 → 0.5.2

package/dist/lib/policy/index.cjs

@@ -0,0 +1,99 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_helpers = require("../../policy/helpers.cjs");
+//#region src/lib/policy/index.ts
+var Policy = class {
+	rules = [];
+	allow(params) {
+		const actions = this.toActions(params.action);
+		for (const action of actions) this.rules.push({
+			action,
+			conditions: params.conditions,
+			inverted: false,
+			reason: params.reason
+		});
+	}
+	forbid(params) {
+		const actions = this.toActions(params.action);
+		for (const action of actions) this.rules.push({
+			action,
+			conditions: params.conditions,
+			inverted: true,
+			reason: params.reason
+		});
+	}
+	toActions(action) {
+		if (Array.isArray(action)) return action;
+		return [action];
+	}
+	can(action, object) {
+		const filteredRules = this.rules.filter((rule) => rule.action === action);
+		const forbidResult = this.checkForbids(filteredRules, object);
+		if (forbidResult) return forbidResult;
+		const allowResult = this.checkAllows(filteredRules, object);
+		if (allowResult) return allowResult;
+		return {
+			allowed: false,
+			reason: void 0
+		};
+	}
+	checkForbids(rules, object) {
+		for (const rule of rules) {
+			if (!rule.inverted) continue;
+			if (!rule.conditions || Object.entries(rule.conditions).length === 0) return {
+				allowed: false,
+				reason: rule.reason
+			};
+			if (object && this.deepMatch(object, rule.conditions)) return {
+				allowed: false,
+				reason: rule.reason
+			};
+		}
+	}
+	checkAllows(rules, object) {
+		for (const rule of rules) {
+			if (rule.inverted) continue;
+			if (!rule.conditions || Object.entries(rule.conditions).length === 0) return {
+				allowed: true,
+				reason: rule.reason
+			};
+			if (object && this.deepMatch(object, rule.conditions)) return {
+				allowed: true,
+				reason: rule.reason
+			};
+		}
+	}
+	deepMatch(objectValue, conditionValue) {
+		if (typeof objectValue !== "object" || objectValue === null) return false;
+		for (const [key, nestedCondition] of Object.entries(conditionValue)) {
+			const nestedValue = Reflect.get(objectValue, key);
+			if (!this.matchValue(nestedValue, nestedCondition)) return false;
+		}
+		return true;
+	}
+	matchValue(actual, condition) {
+		if (typeof condition !== "object" || condition === null) return false;
+		if ("fn" in condition && typeof condition.fn === "function") return condition.fn(actual);
+		return this.deepMatch(actual, condition);
+	}
+};
+//#endregion
+exports.Policy = Policy;
+exports.and = require_helpers.and;
+exports.endsWith = require_helpers.endsWith;
+exports.eq = require_helpers.eq;
+exports.gt = require_helpers.gt;
+exports.gte = require_helpers.gte;
+exports.has = require_helpers.has;
+exports.hasAny = require_helpers.hasAny;
+exports.hasLength = require_helpers.hasLength;
+exports.includes = require_helpers.includes;
+exports.isDefined = require_helpers.isDefined;
+exports.isEmpty = require_helpers.isEmpty;
+exports.isNullish = require_helpers.isNullish;
+exports.lt = require_helpers.lt;
+exports.lte = require_helpers.lte;
+exports.matches = require_helpers.matches;
+exports.neq = require_helpers.neq;
+exports.not = require_helpers.not;
+exports.or = require_helpers.or;
+exports.startsWith = require_helpers.startsWith;

package/dist/lib/policy/index.d.cts

@@ -0,0 +1,21 @@
+import { ConditionHelper, and, endsWith, eq, gt, gte, has, hasAny, hasLength, includes, isDefined, isEmpty, isNullish, lt, lte, matches, neq, not, or, startsWith } from "../../policy/helpers.cjs";
+import { Action, AllowParams, ForbidParams } from "../../policy/types.cjs";
+
+//#region src/lib/policy/index.d.ts
+declare class Policy<TEntity extends Record<string, unknown> = Record<string, unknown>> {
+  private rules;
+  allow(params: AllowParams<TEntity>): void;
+  forbid(params: ForbidParams<TEntity>): void;
+  private toActions;
+  can(action: Action, object?: TEntity): {
+    allowed: boolean;
+    reason: string | undefined;
+  };
+  private checkForbids;
+  private checkAllows;
+  private deepMatch;
+  private matchValue;
+}
+//#endregion
+export { type ConditionHelper, Policy, and, endsWith, eq, gt, gte, has, hasAny, hasLength, includes, isDefined, isEmpty, isNullish, lt, lte, matches, neq, not, or, startsWith };
+//# sourceMappingURL=index.d.cts.map

package/dist/lib/policy/index.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.cts","names":[],"sources":["../../../src/lib/policy/index.ts"],"mappings":";;;;cAEa,MAAA,iBACK,MAAA,oBAA0B,MAAA;EAAA,QAElC,KAAA;EAED,KAAA,CAAM,MAAA,EAAQ,WAAA,CAAY,OAAA;EAa1B,MAAA,CAAO,MAAA,EAAQ,YAAA,CAAa,OAAA;EAAA,QAa3B,SAAA;EAQD,GAAA,CAAI,MAAA,EAAQ,MAAA,EAAQ,MAAA,GAAS,OAAA;;;;UAkB5B,YAAA;EAAA,QAgBA,WAAA;EAAA,QAgBA,SAAA;EAAA,QAgBA,UAAA;AAAA"}

package/dist/lib/policy/index.d.mts

@@ -0,0 +1,21 @@
+import { ConditionHelper, and, endsWith, eq, gt, gte, has, hasAny, hasLength, includes, isDefined, isEmpty, isNullish, lt, lte, matches, neq, not, or, startsWith } from "../../policy/helpers.mjs";
+import { Action, AllowParams, ForbidParams } from "../../policy/types.mjs";
+
+//#region src/lib/policy/index.d.ts
+declare class Policy<TEntity extends Record<string, unknown> = Record<string, unknown>> {
+  private rules;
+  allow(params: AllowParams<TEntity>): void;
+  forbid(params: ForbidParams<TEntity>): void;
+  private toActions;
+  can(action: Action, object?: TEntity): {
+    allowed: boolean;
+    reason: string | undefined;
+  };
+  private checkForbids;
+  private checkAllows;
+  private deepMatch;
+  private matchValue;
+}
+//#endregion
+export { type ConditionHelper, Policy, and, endsWith, eq, gt, gte, has, hasAny, hasLength, includes, isDefined, isEmpty, isNullish, lt, lte, matches, neq, not, or, startsWith };
+//# sourceMappingURL=index.d.mts.map

package/dist/lib/policy/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../../../src/lib/policy/index.ts"],"mappings":";;;;cAEa,MAAA,iBACK,MAAA,oBAA0B,MAAA;EAAA,QAElC,KAAA;EAED,KAAA,CAAM,MAAA,EAAQ,WAAA,CAAY,OAAA;EAa1B,MAAA,CAAO,MAAA,EAAQ,YAAA,CAAa,OAAA;EAAA,QAa3B,SAAA;EAQD,GAAA,CAAI,MAAA,EAAQ,MAAA,EAAQ,MAAA,GAAS,OAAA;;;;UAkB5B,YAAA;EAAA,QAgBA,WAAA;EAAA,QAgBA,SAAA;EAAA,QAgBA,UAAA;AAAA"}

package/dist/lib/policy/index.mjs

@@ -0,0 +1,81 @@
+import { and, endsWith, eq, gt, gte, has, hasAny, hasLength, includes, isDefined, isEmpty, isNullish, lt, lte, matches, neq, not, or, startsWith } from "../../policy/helpers.mjs";
+//#region src/lib/policy/index.ts
+var Policy = class {
+	rules = [];
+	allow(params) {
+		const actions = this.toActions(params.action);
+		for (const action of actions) this.rules.push({
+			action,
+			conditions: params.conditions,
+			inverted: false,
+			reason: params.reason
+		});
+	}
+	forbid(params) {
+		const actions = this.toActions(params.action);
+		for (const action of actions) this.rules.push({
+			action,
+			conditions: params.conditions,
+			inverted: true,
+			reason: params.reason
+		});
+	}
+	toActions(action) {
+		if (Array.isArray(action)) return action;
+		return [action];
+	}
+	can(action, object) {
+		const filteredRules = this.rules.filter((rule) => rule.action === action);
+		const forbidResult = this.checkForbids(filteredRules, object);
+		if (forbidResult) return forbidResult;
+		const allowResult = this.checkAllows(filteredRules, object);
+		if (allowResult) return allowResult;
+		return {
+			allowed: false,
+			reason: void 0
+		};
+	}
+	checkForbids(rules, object) {
+		for (const rule of rules) {
+			if (!rule.inverted) continue;
+			if (!rule.conditions || Object.entries(rule.conditions).length === 0) return {
+				allowed: false,
+				reason: rule.reason
+			};
+			if (object && this.deepMatch(object, rule.conditions)) return {
+				allowed: false,
+				reason: rule.reason
+			};
+		}
+	}
+	checkAllows(rules, object) {
+		for (const rule of rules) {
+			if (rule.inverted) continue;
+			if (!rule.conditions || Object.entries(rule.conditions).length === 0) return {
+				allowed: true,
+				reason: rule.reason
+			};
+			if (object && this.deepMatch(object, rule.conditions)) return {
+				allowed: true,
+				reason: rule.reason
+			};
+		}
+	}
+	deepMatch(objectValue, conditionValue) {
+		if (typeof objectValue !== "object" || objectValue === null) return false;
+		for (const [key, nestedCondition] of Object.entries(conditionValue)) {
+			const nestedValue = Reflect.get(objectValue, key);
+			if (!this.matchValue(nestedValue, nestedCondition)) return false;
+		}
+		return true;
+	}
+	matchValue(actual, condition) {
+		if (typeof condition !== "object" || condition === null) return false;
+		if ("fn" in condition && typeof condition.fn === "function") return condition.fn(actual);
+		return this.deepMatch(actual, condition);
+	}
+};
+//#endregion
+export { Policy, and, endsWith, eq, gt, gte, has, hasAny, hasLength, includes, isDefined, isEmpty, isNullish, lt, lte, matches, neq, not, or, startsWith };
+
+//# sourceMappingURL=index.mjs.map

package/dist/lib/policy/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"sources":["../../../src/lib/policy/index.ts"],"sourcesContent":["import type { Action, AllowParams, ForbidParams, Rule } from \"./types.js\";\n\nexport class Policy<\n  TEntity extends Record<string, unknown> = Record<string, unknown>,\n> {\n  private rules: Rule<TEntity>[] = [];\n\n  public allow(params: AllowParams<TEntity>) {\n    const actions = this.toActions(params.action);\n\n    for (const action of actions) {\n      this.rules.push({\n        action,\n        conditions: params.conditions,\n        inverted: false,\n        reason: params.reason,\n      });\n    }\n  }\n\n  public forbid(params: ForbidParams<TEntity>) {\n    const actions = this.toActions(params.action);\n\n    for (const action of actions) {\n      this.rules.push({\n        action,\n        conditions: params.conditions,\n        inverted: true,\n        reason: params.reason,\n      });\n    }\n  }\n\n  private toActions(action: Action | Action[]) {\n    if (Array.isArray(action)) {\n      return action;\n    }\n\n    return [action];\n  }\n\n  public can(action: Action, object?: TEntity) {\n    const filteredRules = this.rules.filter((rule) => rule.action === action);\n\n    const forbidResult = this.checkForbids(filteredRules, object);\n\n    if (forbidResult) {\n      return forbidResult;\n    }\n\n    const allowResult = this.checkAllows(filteredRules, object);\n\n    if (allowResult) {\n      return allowResult;\n    }\n\n    return { allowed: false, reason: undefined };\n  }\n\n  private checkForbids(rules: Rule<TEntity>[], object?: TEntity) {\n    for (const rule of rules) {\n      if (!rule.inverted) {\n        continue;\n      }\n\n      if (!rule.conditions || Object.entries(rule.conditions).length === 0) {\n        return { allowed: false, reason: rule.reason };\n      }\n\n      if (object && this.deepMatch(object, rule.conditions)) {\n        return { allowed: false, reason: rule.reason };\n      }\n    }\n  }\n\n  private checkAllows(rules: Rule<TEntity>[], object?: TEntity) {\n    for (const rule of rules) {\n      if (rule.inverted) {\n        continue;\n      }\n\n      if (!rule.conditions || Object.entries(rule.conditions).length === 0) {\n        return { allowed: true, reason: rule.reason };\n      }\n\n      if (object && this.deepMatch(object, rule.conditions)) {\n        return { allowed: true, reason: rule.reason };\n      }\n    }\n  }\n\n  private deepMatch(objectValue: unknown, conditionValue: object) {\n    if (typeof objectValue !== \"object\" || objectValue === null) {\n      return false;\n    }\n\n    for (const [key, nestedCondition] of Object.entries(conditionValue)) {\n      const nestedValue = Reflect.get(objectValue, key);\n\n      if (!this.matchValue(nestedValue, nestedCondition)) {\n        return false;\n      }\n    }\n\n    return true;\n  }\n\n  private matchValue(actual: unknown, condition: unknown) {\n    if (typeof condition !== \"object\" || condition === null) {\n      return false;\n    }\n\n    if (\"fn\" in condition && typeof condition.fn === \"function\") {\n      return condition.fn(actual);\n    }\n\n    return this.deepMatch(actual, condition);\n  }\n}\n\nexport type { ConditionHelper } from \"./helpers.js\";\nexport {\n  and,\n  endsWith,\n  eq,\n  gt,\n  gte,\n  has,\n  hasAny,\n  hasLength,\n  includes,\n  isDefined,\n  isEmpty,\n  isNullish,\n  lt,\n  lte,\n  matches,\n  neq,\n  not,\n  or,\n  startsWith,\n} from \"./helpers.js\";\n"],"mappings":";;AAEA,IAAa,SAAb,MAEE;CACA,QAAiC,EAAE;CAEnC,MAAa,QAA8B;EACzC,MAAM,UAAU,KAAK,UAAU,OAAO,OAAO;AAE7C,OAAK,MAAM,UAAU,QACnB,MAAK,MAAM,KAAK;GACd;GACA,YAAY,OAAO;GACnB,UAAU;GACV,QAAQ,OAAO;GAChB,CAAC;;CAIN,OAAc,QAA+B;EAC3C,MAAM,UAAU,KAAK,UAAU,OAAO,OAAO;AAE7C,OAAK,MAAM,UAAU,QACnB,MAAK,MAAM,KAAK;GACd;GACA,YAAY,OAAO;GACnB,UAAU;GACV,QAAQ,OAAO;GAChB,CAAC;;CAIN,UAAkB,QAA2B;AAC3C,MAAI,MAAM,QAAQ,OAAO,CACvB,QAAO;AAGT,SAAO,CAAC,OAAO;;CAGjB,IAAW,QAAgB,QAAkB;EAC3C,MAAM,gBAAgB,KAAK,MAAM,QAAQ,SAAS,KAAK,WAAW,OAAO;EAEzE,MAAM,eAAe,KAAK,aAAa,eAAe,OAAO;AAE7D,MAAI,aACF,QAAO;EAGT,MAAM,cAAc,KAAK,YAAY,eAAe,OAAO;AAE3D,MAAI,YACF,QAAO;AAGT,SAAO;GAAE,SAAS;GAAO,QAAQ,KAAA;GAAW;;CAG9C,aAAqB,OAAwB,QAAkB;AAC7D,OAAK,MAAM,QAAQ,OAAO;AACxB,OAAI,CAAC,KAAK,SACR;AAGF,OAAI,CAAC,KAAK,cAAc,OAAO,QAAQ,KAAK,WAAW,CAAC,WAAW,EACjE,QAAO;IAAE,SAAS;IAAO,QAAQ,KAAK;IAAQ;AAGhD,OAAI,UAAU,KAAK,UAAU,QAAQ,KAAK,WAAW,CACnD,QAAO;IAAE,SAAS;IAAO,QAAQ,KAAK;IAAQ;;;CAKpD,YAAoB,OAAwB,QAAkB;AAC5D,OAAK,MAAM,QAAQ,OAAO;AACxB,OAAI,KAAK,SACP;AAGF,OAAI,CAAC,KAAK,cAAc,OAAO,QAAQ,KAAK,WAAW,CAAC,WAAW,EACjE,QAAO;IAAE,SAAS;IAAM,QAAQ,KAAK;IAAQ;AAG/C,OAAI,UAAU,KAAK,UAAU,QAAQ,KAAK,WAAW,CACnD,QAAO;IAAE,SAAS;IAAM,QAAQ,KAAK;IAAQ;;;CAKnD,UAAkB,aAAsB,gBAAwB;AAC9D,MAAI,OAAO,gBAAgB,YAAY,gBAAgB,KACrD,QAAO;AAGT,OAAK,MAAM,CAAC,KAAK,oBAAoB,OAAO,QAAQ,eAAe,EAAE;GACnE,MAAM,cAAc,QAAQ,IAAI,aAAa,IAAI;AAEjD,OAAI,CAAC,KAAK,WAAW,aAAa,gBAAgB,CAChD,QAAO;;AAIX,SAAO;;CAGT,WAAmB,QAAiB,WAAoB;AACtD,MAAI,OAAO,cAAc,YAAY,cAAc,KACjD,QAAO;AAGT,MAAI,QAAQ,aAAa,OAAO,UAAU,OAAO,WAC/C,QAAO,UAAU,GAAG,OAAO;AAG7B,SAAO,KAAK,UAAU,QAAQ,UAAU"}

package/dist/lib/prompts/index.cjs

@@ -0,0 +1,409 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_runtime = require("../../prompts/core/runtime.cjs");
+const require_session = require("../../prompts/core/session.cjs");
+let node_util = require("node:util");
+//#region src/lib/prompts/index.ts
+const pointer = (active) => {
+	return active ? paint("cyan", "❯") : " ";
+};
+const addErrorLine = (content, errorMessage) => {
+	if (!errorMessage) return content;
+	return `${content}\n${errorMark()} ${paint("red", errorMessage)}`;
+};
+const insertAt = (value, at, character) => {
+	return `${value.slice(0, at)}${character}${value.slice(at)}`;
+};
+const INVERSE = "\x1B[7m";
+const RESET = "\x1B[0m";
+const WHITESPACE = /\s/;
+const NUMBER_CHAR = /[0-9.-]/;
+const CURSOR_BLOCK = `${INVERSE} ${RESET}`;
+const paint = (color, text) => {
+	return (0, node_util.styleText)(color, text, { validateStream: false });
+};
+const questionMark = () => paint("cyan", "?");
+const successMark = () => paint("green", "✔");
+const errorMark = () => paint("red", "✖");
+const renderQuestionLine = (message, content) => {
+	return `${questionMark()} ${paint("cyan", message)} ${content}`;
+};
+const renderSuccessLine = (message, content) => {
+	return `${successMark()} ${message} ${content}`;
+};
+const createTextState = (value) => {
+	return {
+		value,
+		cursor: value.length,
+		selectionAnchor: null
+	};
+};
+const submitTextValue = (state, options) => {
+	const value = state.value.length > 0 ? state.value : options.defaultValue ?? "";
+	if (options.required && value.trim().length === 0) return { errorMessage: options.requiredMessage ?? "A value is required" };
+	return { value };
+};
+const getSelectionRange = (state) => {
+	if (state.selectionAnchor === null || state.selectionAnchor === state.cursor) return null;
+	return {
+		start: Math.min(state.selectionAnchor, state.cursor),
+		end: Math.max(state.selectionAnchor, state.cursor)
+	};
+};
+const moveCursor = (state, cursor, keepSelection) => {
+	if (!keepSelection) return {
+		...state,
+		cursor,
+		selectionAnchor: null
+	};
+	return {
+		...state,
+		cursor,
+		selectionAnchor: state.selectionAnchor ?? state.cursor
+	};
+};
+const deleteRange = (state, start, end) => {
+	return {
+		value: `${state.value.slice(0, start)}${state.value.slice(end)}`,
+		cursor: start,
+		selectionAnchor: null
+	};
+};
+const deleteSelectedRange = (state) => {
+	const selection = getSelectionRange(state);
+	if (!selection) return state;
+	return deleteRange(state, selection.start, selection.end);
+};
+const findWordStart = (value, cursor) => {
+	let index = cursor;
+	while (index > 0 && WHITESPACE.test(value[index - 1] ?? "")) index -= 1;
+	while (index > 0 && !WHITESPACE.test(value[index - 1] ?? "")) index -= 1;
+	return index;
+};
+const findWordEnd = (value, cursor) => {
+	let index = cursor;
+	while (index < value.length && WHITESPACE.test(value[index] ?? "")) index += 1;
+	while (index < value.length && !WHITESPACE.test(value[index] ?? "")) index += 1;
+	return index;
+};
+const renderTextSelection = (state, mask) => {
+	const selection = getSelectionRange(state);
+	const content = mask ? mask.repeat(state.value.length) : state.value;
+	const boundedCursor = Math.max(0, Math.min(state.cursor, content.length));
+	if (!selection) {
+		if (content.length === 0) return CURSOR_BLOCK;
+		if (boundedCursor === content.length) return `${content}${CURSOR_BLOCK}`;
+		const focusedChar = content[boundedCursor] ?? " ";
+		return `${content.slice(0, boundedCursor)}${INVERSE}${focusedChar}${RESET}${content.slice(boundedCursor + 1)}`;
+	}
+	const selected = content.slice(selection.start, selection.end);
+	return `${content.slice(0, selection.start)}${INVERSE}${selected}${RESET}${content.slice(selection.end)}`;
+};
+const textOnKey = (state, key) => {
+	switch (key.name) {
+		case "ctrl_a": return {
+			...state,
+			cursor: state.value.length,
+			selectionAnchor: 0
+		};
+		case "home": return moveCursor(state, 0, false);
+		case "end": return moveCursor(state, state.value.length, false);
+		case "shift_ctrl_left": return moveCursor(state, findWordStart(state.value, state.cursor), true);
+		case "shift_ctrl_right": return moveCursor(state, findWordEnd(state.value, state.cursor), true);
+		case "left": return moveCursor(state, Math.max(state.cursor - 1, 0), false);
+		case "shift_left": return moveCursor(state, Math.max(state.cursor - 1, 0), true);
+		case "right": return moveCursor(state, Math.min(state.cursor + 1, state.value.length), false);
+		case "ctrl_left": return moveCursor(state, findWordStart(state.value, state.cursor), false);
+		case "ctrl_right": return moveCursor(state, findWordEnd(state.value, state.cursor), false);
+		case "shift_right": return moveCursor(state, Math.min(state.cursor + 1, state.value.length), true);
+		case "backspace": {
+			const selectionDeleted = deleteSelectedRange(state);
+			if (selectionDeleted !== state) return selectionDeleted;
+			if (state.cursor === 0) return state;
+			const nextCursor = state.cursor - 1;
+			return {
+				value: `${state.value.slice(0, nextCursor)}${state.value.slice(state.cursor)}`,
+				cursor: nextCursor,
+				selectionAnchor: null
+			};
+		}
+		case "ctrl_backspace": {
+			const selectionDeleted = deleteSelectedRange(state);
+			if (selectionDeleted !== state) return selectionDeleted;
+			if (state.cursor === 0) return state;
+			return deleteRange(state, findWordStart(state.value, state.cursor), state.cursor);
+		}
+		case "delete": {
+			const selectionDeleted = deleteSelectedRange(state);
+			if (selectionDeleted !== state) return selectionDeleted;
+			return {
+				...state,
+				value: `${state.value.slice(0, state.cursor)}${state.value.slice(state.cursor + 1)}`
+			};
+		}
+		case "character":
+		case "space": {
+			const collapsed = deleteSelectedRange(state);
+			const text = key.name === "space" ? " " : key.value ?? "";
+			return {
+				value: insertAt(collapsed.value, collapsed.cursor, text),
+				cursor: collapsed.cursor + 1,
+				selectionAnchor: null
+			};
+		}
+		default: return state;
+	}
+};
+const input = async (options, runtime) => {
+	return require_session.runPromptSession({
+		runtime: runtime ?? require_runtime.createNodePromptRuntime(),
+		options,
+		initialState: createTextState(options.defaultValue ?? ""),
+		render: ({ options: currentOptions, state, errorMessage }) => {
+			let text = renderTextSelection(state);
+			if (state.value.length === 0 && currentOptions.placeholder) text = `${CURSOR_BLOCK}${paint("dim", currentOptions.placeholder)}`;
+			return addErrorLine(renderQuestionLine(currentOptions.message, text), errorMessage);
+		},
+		complete: ({ options: currentOptions, value }) => {
+			return renderSuccessLine(currentOptions.message, value);
+		},
+		onKey: (state, key) => {
+			return textOnKey(state, key);
+		},
+		onSubmit: (state) => submitTextValue(state, options)
+	});
+};
+const password = async (options, runtime) => {
+	const promptRuntime = runtime ?? require_runtime.createNodePromptRuntime();
+	const initialValue = options.defaultValue ?? "";
+	const mask = options.mask;
+	return require_session.runPromptSession({
+		runtime: promptRuntime,
+		options,
+		initialState: createTextState(initialValue),
+		render: ({ options: currentOptions, state, errorMessage }) => {
+			let visible;
+			if (state.value.length === 0 && currentOptions.placeholder) visible = `${CURSOR_BLOCK}${paint("dim", currentOptions.placeholder)}`;
+			else if (mask !== void 0) visible = renderTextSelection(state, mask);
+			else visible = CURSOR_BLOCK;
+			return addErrorLine(renderQuestionLine(currentOptions.message, visible), errorMessage);
+		},
+		complete: ({ options: currentOptions, value }) => {
+			return renderSuccessLine(currentOptions.message, mask !== void 0 ? mask.repeat(value.length) : "");
+		},
+		onKey: (state, key) => {
+			return textOnKey(state, key);
+		},
+		onSubmit: (state) => submitTextValue(state, options)
+	});
+};
+const confirm = async (options, runtime) => {
+	return require_session.runPromptSession({
+		runtime: runtime ?? require_runtime.createNodePromptRuntime(),
+		options,
+		initialState: { value: options.defaultValue ?? false },
+		render: ({ options: currentOptions, state, errorMessage }) => {
+			const yesLabel = currentOptions.activeLabel ?? "Yes";
+			const noLabel = currentOptions.inactiveLabel ?? "No";
+			const rendered = state.value ? yesLabel : noLabel;
+			return addErrorLine([renderQuestionLine(currentOptions.message, `(${rendered})`), paint("dim", "  (y/n to select, ← yes / → no, space to toggle)")].join("\n"), errorMessage);
+		},
+		complete: ({ options: currentOptions, value }) => {
+			const label = value ? currentOptions.activeLabel ?? "Yes" : currentOptions.inactiveLabel ?? "No";
+			return renderSuccessLine(currentOptions.message, label);
+		},
+		onKey: (state, key) => {
+			switch (key.name) {
+				case "left": return { value: true };
+				case "right": return { value: false };
+				case "space": return { value: !state.value };
+				case "character": {
+					const lowered = (key.value ?? "").toLowerCase();
+					if (lowered === "y") return { value: true };
+					if (lowered === "n") return { value: false };
+					return state;
+				}
+				default: return state;
+			}
+		},
+		onSubmit: (state) => {
+			return { value: state.value };
+		}
+	});
+};
+const number = async (options, runtime) => {
+	return require_session.runPromptSession({
+		runtime: runtime ?? require_runtime.createNodePromptRuntime(),
+		options,
+		initialState: createTextState(options.defaultValue === void 0 ? "" : String(options.defaultValue)),
+		render: ({ options: currentOptions, state, errorMessage }) => {
+			return addErrorLine(renderQuestionLine(currentOptions.message, renderTextSelection(state)), errorMessage);
+		},
+		complete: ({ options: currentOptions, value }) => {
+			return renderSuccessLine(currentOptions.message, String(value));
+		},
+		onKey: (state, key) => {
+			const next = textOnKey(state, key);
+			if (!(key.name === "character" || key.name === "space")) return next;
+			const value = key.name === "space" ? " " : key.value ?? "";
+			if (!NUMBER_CHAR.test(value)) return state;
+			if (value === "." || value === "-") {
+				const collapsed = deleteSelectedRange(state);
+				if (value === "." && collapsed.value.includes(".")) return state;
+				if (value === "-") {
+					if (collapsed.cursor !== 0) return state;
+					if (collapsed.value.includes("-")) return state;
+				}
+			}
+			return next;
+		},
+		onSubmit: (state) => {
+			const raw = state.value.trim();
+			if (raw.length === 0) return { errorMessage: options.requiredMessage ?? "A number is required" };
+			const parsed = Number(raw);
+			if (!Number.isFinite(parsed)) return { errorMessage: options.invalidMessage ?? "Please enter a valid number" };
+			if (options.min !== void 0 && parsed < options.min) return { errorMessage: options.minMessage ?? `Number must be greater than or equal to ${options.min}` };
+			if (options.max !== void 0 && parsed > options.max) return { errorMessage: options.maxMessage ?? `Number must be lower than or equal to ${options.max}` };
+			return { value: parsed };
+		}
+	});
+};
+const findFirstEnabledIndex = (choices) => {
+	const firstEnabledIndex = choices.findIndex((choice) => !choice.disabled);
+	if (firstEnabledIndex >= 0) return firstEnabledIndex;
+	return 0;
+};
+const findNextEnabledIndex = (choices, cursor, direction) => {
+	const total = choices.length;
+	let currentCursor = cursor;
+	for (let offset = 0; offset < total; offset++) {
+		const nextCursor = (currentCursor + direction + total) % total;
+		const nextChoice = choices[nextCursor];
+		if (nextChoice && !nextChoice.disabled) return nextCursor;
+		currentCursor = nextCursor;
+	}
+	return currentCursor;
+};
+const findDefaultIndex = (choices, defaultValue) => {
+	if (defaultValue === void 0) return findFirstEnabledIndex(choices);
+	const index = choices.findIndex((choice) => choice.value === defaultValue && !choice.disabled);
+	if (index >= 0) return index;
+	return findFirstEnabledIndex(choices);
+};
+const select = async (options, runtime) => {
+	return require_session.runPromptSession({
+		runtime: runtime ?? require_runtime.createNodePromptRuntime(),
+		options,
+		initialState: { cursor: findDefaultIndex(options.choices, options.defaultValue) },
+		render: ({ options: currentOptions, state, errorMessage }) => {
+			const lines = [renderQuestionLine(currentOptions.message, "")];
+			for (let index = 0; index < currentOptions.choices.length; index++) {
+				const choice = currentOptions.choices[index];
+				if (!choice) continue;
+				const active = state.cursor === index;
+				const label = choice.label ?? choice.value;
+				const hint = choice.hint ? paint("dim", ` (${choice.hint})`) : "";
+				const disabled = choice.disabled ? paint("yellow", " [disabled]") : "";
+				lines.push(`${pointer(active)} ${label}${hint}${disabled}`);
+			}
+			return addErrorLine(lines.join("\n"), errorMessage);
+		},
+		complete: ({ options: currentOptions, value }) => {
+			const selected = currentOptions.choices.find((choice) => choice.value === value);
+			return renderSuccessLine(currentOptions.message, selected?.label ?? value);
+		},
+		onKey: (state, key) => {
+			switch (key.name) {
+				case "up": return { cursor: findNextEnabledIndex(options.choices, state.cursor, -1) };
+				case "down": return { cursor: findNextEnabledIndex(options.choices, state.cursor, 1) };
+				default: return state;
+			}
+		},
+		onSubmit: (state) => {
+			const selectedChoice = options.choices[state.cursor];
+			if (!selectedChoice) return { errorMessage: "Please select an option" };
+			if (selectedChoice.disabled) return { errorMessage: "Selected option is disabled" };
+			return { value: selectedChoice.value };
+		}
+	});
+};
+const multiselect = async (options, runtime) => {
+	return require_session.runPromptSession({
+		runtime: runtime ?? require_runtime.createNodePromptRuntime(),
+		options,
+		initialState: {
+			cursor: findFirstEnabledIndex(options.choices),
+			selected: new Set(options.defaultValue ?? [])
+		},
+		render: ({ options: currentOptions, state, errorMessage }) => {
+			const lines = [renderQuestionLine(currentOptions.message, "")];
+			for (let index = 0; index < currentOptions.choices.length; index++) {
+				const choice = currentOptions.choices[index];
+				if (!choice) continue;
+				const active = state.cursor === index;
+				const checked = state.selected.has(choice.value) ? "◉" : "◯";
+				const disabled = choice.disabled ? paint("yellow", " [disabled]") : "";
+				const label = choice.label ?? choice.value;
+				const hint = choice.hint ? paint("dim", ` (${choice.hint})`) : "";
+				lines.push(`${pointer(active)} ${checked} ${label}${hint}${disabled}`);
+			}
+			lines.push(paint("dim", "  (space to toggle, a to toggle all, enter to submit)"));
+			return addErrorLine(lines.join("\n"), errorMessage);
+		},
+		complete: ({ options: currentOptions, value }) => {
+			const labelMap = new Map(currentOptions.choices.map((choice) => [choice.value, choice.label]));
+			const labels = value.map((v) => labelMap.get(v) ?? v);
+			return renderSuccessLine(currentOptions.message, labels.join(", "));
+		},
+		onKey: (state, key) => {
+			switch (key.name) {
+				case "up": return {
+					...state,
+					cursor: findNextEnabledIndex(options.choices, state.cursor, -1)
+				};
+				case "down": return {
+					...state,
+					cursor: findNextEnabledIndex(options.choices, state.cursor, 1)
+				};
+				case "character":
+					if ((key.value ?? "").toLowerCase() === "a") {
+						const enabledValues = options.choices.filter((choice) => !choice.disabled).map((choice) => choice.value);
+						if (!(enabledValues.length > 0)) return state;
+						const areAllEnabledSelected = enabledValues.every((value) => state.selected.has(value));
+						const nextSelection = new Set(state.selected);
+						if (areAllEnabledSelected) for (const value of enabledValues) nextSelection.delete(value);
+						else for (const value of enabledValues) nextSelection.add(value);
+						return {
+							...state,
+							selected: nextSelection
+						};
+					}
+					return state;
+				case "space": {
+					const currentChoice = options.choices[state.cursor];
+					if (!currentChoice || currentChoice.disabled) return state;
+					const nextSelection = new Set(state.selected);
+					if (nextSelection.has(currentChoice.value)) nextSelection.delete(currentChoice.value);
+					else nextSelection.add(currentChoice.value);
+					return {
+						...state,
+						selected: nextSelection
+					};
+				}
+				default: return state;
+			}
+		},
+		onSubmit: (state) => {
+			const values = options.choices.filter((choice) => state.selected.has(choice.value)).map((choice) => choice.value);
+			if (options.min !== void 0 && values.length < options.min) return { errorMessage: `Please select at least ${options.min} options` };
+			if (options.max !== void 0 && values.length > options.max) return { errorMessage: `Please select at most ${options.max} options` };
+			return { value: values };
+		}
+	});
+};
+//#endregion
+exports.confirm = confirm;
+exports.input = input;
+exports.multiselect = multiselect;
+exports.number = number;
+exports.password = password;
+exports.select = select;