@maizzle/framework 6.0.0-rc.9 → 6.0.0

package/dist/utils/output-markers.d.ts

@@ -0,0 +1,29 @@
+//#region src/utils/output-markers.d.ts
+/**
+ * Sentinel attributes the `<Plaintext>` and `<NotPlaintext>`
+ * components stamp on their wrapper `<div>` so the build step
+ * can route their slot content to one output and remove it
+ * entirely from the other.
+ */
+declare const PLAINTEXT_ONLY_ATTR = "data-maizzle-plaintext-only";
+declare const HTML_ONLY_ATTR = "data-maizzle-html-only";
+/**
+ * Strip output markers for the HTML output: drop plaintext-only
+ * subtrees entirely, unwrap html-only wrappers (keep children).
+ *
+ * When no markers are present, the input is returned unchanged so
+ * the post-transformer formatting (prettify, XHTML self-closing
+ * slashes, etc.) survives intact for the typical case.
+ */
+declare function stripForHtml(html: string): string;
+/**
+ * Strip output markers for the plaintext source: drop html-only
+ * subtrees entirely, unwrap plaintext-only wrappers (keep children).
+ *
+ * The result is fed to `createPlaintext`, which then strips all
+ * remaining tags via `string-strip-html`.
+ */
+declare function stripForPlaintext(html: string): string;
+//#endregion
+export { HTML_ONLY_ATTR, PLAINTEXT_ONLY_ATTR, stripForHtml, stripForPlaintext };
+//# sourceMappingURL=output-markers.d.ts.map

package/dist/utils/output-markers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"output-markers.d.ts","names":[],"sources":["../../src/utils/output-markers.ts"],"mappings":";;AASA;;;;AAAgC;cAAnB,mBAAA;AAAA,cACA,cAAA;;;AAAc;AA+C3B;;;;AAAyC;iBAAzB,YAAA,CAAa,IAAY;;;;AAgBK;;;;iBAA9B,iBAAA,CAAkB,IAAY"}

package/dist/utils/output-markers.js

@@ -0,0 +1,68 @@
+import { parse } from "./ast/parser.js";
+import { serialize } from "./ast/serializer.js";
+import "./ast/index.js";
+//#region src/utils/output-markers.ts
+/**
+* Sentinel attributes the `<Plaintext>` and `<NotPlaintext>`
+* components stamp on their wrapper `<div>` so the build step
+* can route their slot content to one output and remove it
+* entirely from the other.
+*/
+const PLAINTEXT_ONLY_ATTR = "data-maizzle-plaintext-only";
+const HTML_ONLY_ATTR = "data-maizzle-html-only";
+const isElement = (n) => n.type === "tag";
+/**
+* Apply marker rules to a forest of nodes.
+*
+* - `drop` removes the matched element and its descendants.
+* - `unwrap` removes the wrapper element but keeps its children,
+*   splicing them into the parent's child list in place.
+*
+* Non-matching elements recurse so nested markers are handled.
+*/
+function applyRules(nodes, rules) {
+	const out = [];
+	for (const n of nodes) {
+		if (isElement(n)) {
+			const match = rules.find(([attr]) => n.attribs?.[attr] !== void 0);
+			if (match) {
+				const [, op] = match;
+				if (op === "drop") continue;
+				out.push(...applyRules(n.children ?? [], rules));
+				continue;
+			}
+			if (n.children?.length) n.children = applyRules(n.children, rules);
+		}
+		out.push(n);
+	}
+	return out;
+}
+const hasMarkers = (html) => html.includes("data-maizzle-plaintext-only") || html.includes("data-maizzle-html-only");
+/**
+* Strip output markers for the HTML output: drop plaintext-only
+* subtrees entirely, unwrap html-only wrappers (keep children).
+*
+* When no markers are present, the input is returned unchanged so
+* the post-transformer formatting (prettify, XHTML self-closing
+* slashes, etc.) survives intact for the typical case.
+*/
+function stripForHtml(html) {
+	if (!hasMarkers(html)) return html;
+	const isXhtml = /<!DOCTYPE\s+[^>]*xhtml/i.test(html);
+	return serialize(applyRules(parse(html), [[PLAINTEXT_ONLY_ATTR, "drop"], [HTML_ONLY_ATTR, "unwrap"]]), { selfClosingTags: isXhtml });
+}
+/**
+* Strip output markers for the plaintext source: drop html-only
+* subtrees entirely, unwrap plaintext-only wrappers (keep children).
+*
+* The result is fed to `createPlaintext`, which then strips all
+* remaining tags via `string-strip-html`.
+*/
+function stripForPlaintext(html) {
+	if (!hasMarkers(html)) return html;
+	return serialize(applyRules(parse(html), [[HTML_ONLY_ATTR, "drop"], [PLAINTEXT_ONLY_ATTR, "unwrap"]]));
+}
+//#endregion
+export { HTML_ONLY_ATTR, PLAINTEXT_ONLY_ATTR, stripForHtml, stripForPlaintext };
+
+//# sourceMappingURL=output-markers.js.map

package/dist/utils/output-markers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"output-markers.js","names":[],"sources":["../../src/utils/output-markers.ts"],"sourcesContent":["import { parse, serialize } from './ast/index.ts'\nimport type { ChildNode, Element } from 'domhandler'\n\n/**\n * Sentinel attributes the `<Plaintext>` and `<NotPlaintext>`\n * components stamp on their wrapper `<div>` so the build step\n * can route their slot content to one output and remove it\n * entirely from the other.\n */\nexport const PLAINTEXT_ONLY_ATTR = 'data-maizzle-plaintext-only'\nexport const HTML_ONLY_ATTR = 'data-maizzle-html-only'\n\ntype Op = 'drop' | 'unwrap'\ntype Rule = readonly [attr: string, op: Op]\n\nconst isElement = (n: ChildNode): n is Element => n.type === 'tag'\n\n/**\n * Apply marker rules to a forest of nodes.\n *\n * - `drop` removes the matched element and its descendants.\n * - `unwrap` removes the wrapper element but keeps its children,\n *   splicing them into the parent's child list in place.\n *\n * Non-matching elements recurse so nested markers are handled.\n */\nfunction applyRules(nodes: ChildNode[], rules: readonly Rule[]): ChildNode[] {\n  const out: ChildNode[] = []\n  for (const n of nodes) {\n    if (isElement(n)) {\n      const match = rules.find(([attr]) => n.attribs?.[attr] !== undefined)\n      if (match) {\n        const [, op] = match\n        if (op === 'drop') continue\n        out.push(...applyRules((n.children ?? []) as ChildNode[], rules))\n        continue\n      }\n      if (n.children?.length) {\n        n.children = applyRules(n.children as ChildNode[], rules) as Element['children']\n      }\n    }\n    out.push(n)\n  }\n  return out\n}\n\nconst hasMarkers = (html: string): boolean =>\n  html.includes(PLAINTEXT_ONLY_ATTR) || html.includes(HTML_ONLY_ATTR)\n\n/**\n * Strip output markers for the HTML output: drop plaintext-only\n * subtrees entirely, unwrap html-only wrappers (keep children).\n *\n * When no markers are present, the input is returned unchanged so\n * the post-transformer formatting (prettify, XHTML self-closing\n * slashes, etc.) survives intact for the typical case.\n */\nexport function stripForHtml(html: string): string {\n  if (!hasMarkers(html)) return html\n  const isXhtml = /<!DOCTYPE\\s+[^>]*xhtml/i.test(html)\n  return serialize(applyRules(parse(html), [\n    [PLAINTEXT_ONLY_ATTR, 'drop'],\n    [HTML_ONLY_ATTR, 'unwrap'],\n  ]), { selfClosingTags: isXhtml })\n}\n\n/**\n * Strip output markers for the plaintext source: drop html-only\n * subtrees entirely, unwrap plaintext-only wrappers (keep children).\n *\n * The result is fed to `createPlaintext`, which then strips all\n * remaining tags via `string-strip-html`.\n */\nexport function stripForPlaintext(html: string): string {\n  if (!hasMarkers(html)) return html\n  return serialize(applyRules(parse(html), [\n    [HTML_ONLY_ATTR, 'drop'],\n    [PLAINTEXT_ONLY_ATTR, 'unwrap'],\n  ]))\n}\n"],"mappings":";;;;;;;;;;AASA,MAAa,sBAAsB;AACnC,MAAa,iBAAiB;AAK9B,MAAM,aAAa,MAA+B,EAAE,SAAS;;;;;;;;;;AAW7D,SAAS,WAAW,OAAoB,OAAqC;CAC3E,MAAM,MAAmB,CAAC;CAC1B,KAAK,MAAM,KAAK,OAAO;EACrB,IAAI,UAAU,CAAC,GAAG;GAChB,MAAM,QAAQ,MAAM,MAAM,CAAC,UAAU,EAAE,UAAU,UAAU,KAAA,CAAS;GACpE,IAAI,OAAO;IACT,MAAM,GAAG,MAAM;IACf,IAAI,OAAO,QAAQ;IACnB,IAAI,KAAK,GAAG,WAAY,EAAE,YAAY,CAAC,GAAmB,KAAK,CAAC;IAChE;GACF;GACA,IAAI,EAAE,UAAU,QACd,EAAE,WAAW,WAAW,EAAE,UAAyB,KAAK;EAE5D;EACA,IAAI,KAAK,CAAC;CACZ;CACA,OAAO;AACT;AAEA,MAAM,cAAc,SAClB,KAAK,SAAA,6BAA4B,KAAK,KAAK,SAAA,wBAAuB;;;;;;;;;AAUpE,SAAgB,aAAa,MAAsB;CACjD,IAAI,CAAC,WAAW,IAAI,GAAG,OAAO;CAC9B,MAAM,UAAU,0BAA0B,KAAK,IAAI;CACnD,OAAO,UAAU,WAAW,MAAM,IAAI,GAAG,CACvC,CAAC,qBAAqB,MAAM,GAC5B,CAAC,gBAAgB,QAAQ,CAC3B,CAAC,GAAG,EAAE,iBAAiB,QAAQ,CAAC;AAClC;;;;;;;;AASA,SAAgB,kBAAkB,MAAsB;CACtD,IAAI,CAAC,WAAW,IAAI,GAAG,OAAO;CAC9B,OAAO,UAAU,WAAW,MAAM,IAAI,GAAG,CACvC,CAAC,gBAAgB,MAAM,GACvB,CAAC,qBAAqB,QAAQ,CAChC,CAAC,CAAC;AACJ"}

package/dist/utils/{url.d.mts → url.d.ts}

@@ -5,4 +5,4 @@ declare function isAbsoluteUrl(url: string): boolean;
 declare function processSrcset(srcset: string, baseUrl: string): string;
 //#endregion
 export { defaultTags, isAbsoluteUrl, processSrcset, urlAttributes };
-//# sourceMappingURL=url.d.mts.map
+//# sourceMappingURL=url.d.ts.map

package/dist/utils/url.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"url.d.ts","names":[],"sources":["../../src/utils/url.ts"],"mappings":";cAEa,WAAA,EAAa,MAAM;AAAA,cAcnB,aAAA;AAAA,iBAEG,aAAA,CAAc,GAAW;AAAA,iBAMzB,aAAA,CAAc,MAAA,UAAgB,OAAe"}

package/dist/utils/{url.mjs → url.js}

@@ -1,5 +1,4 @@
 import isUrl from "is-url-superb";
-
 //#region src/utils/url.ts
 const defaultTags = {
 	a: ["href"],
@@ -26,7 +25,7 @@ function processSrcset(srcset, baseUrl) {
 		return parts.join(" ");
 	}).join(", ");
 }
-
 //#endregion
 export { defaultTags, isAbsoluteUrl, processSrcset, urlAttributes };
-//# sourceMappingURL=url.mjs.map
+
+//# sourceMappingURL=url.js.map

package/dist/utils/url.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"url.js","names":[],"sources":["../../src/utils/url.ts"],"sourcesContent":["import isUrl from 'is-url-superb'\n\nexport const defaultTags: Record<string, string[]> = {\n  a: ['href'],\n  img: ['src', 'srcset'],\n  video: ['src', 'poster'],\n  source: ['src', 'srcset'],\n  link: ['href'],\n  script: ['src'],\n  object: ['data'],\n  embed: ['src'],\n  iframe: ['src'],\n  'v:image': ['src'],\n  'v:fill': ['src'],\n}\n\nexport const urlAttributes = [...new Set(Object.values(defaultTags).flat())]\n\nexport function isAbsoluteUrl(url: string): boolean {\n  if (!url) return true\n\n  return url.startsWith('//') || url.startsWith('#') || url.startsWith('?') || isUrl(url)\n}\n\nexport function processSrcset(srcset: string, baseUrl: string): string {\n  return srcset.split(',').map(entry => {\n    const parts = entry.trim().split(/\\s+/)\n\n    if (parts[0] && !isAbsoluteUrl(parts[0])) {\n      parts[0] = baseUrl + parts[0]\n    }\n\n    return parts.join(' ')\n  }).join(', ')\n}\n"],"mappings":";;AAEA,MAAa,cAAwC;CACnD,GAAG,CAAC,MAAM;CACV,KAAK,CAAC,OAAO,QAAQ;CACrB,OAAO,CAAC,OAAO,QAAQ;CACvB,QAAQ,CAAC,OAAO,QAAQ;CACxB,MAAM,CAAC,MAAM;CACb,QAAQ,CAAC,KAAK;CACd,QAAQ,CAAC,MAAM;CACf,OAAO,CAAC,KAAK;CACb,QAAQ,CAAC,KAAK;CACd,WAAW,CAAC,KAAK;CACjB,UAAU,CAAC,KAAK;AAClB;AAEA,MAAa,gBAAgB,CAAC,GAAG,IAAI,IAAI,OAAO,OAAO,WAAW,CAAC,CAAC,KAAK,CAAC,CAAC;AAE3E,SAAgB,cAAc,KAAsB;CAClD,IAAI,CAAC,KAAK,OAAO;CAEjB,OAAO,IAAI,WAAW,IAAI,KAAK,IAAI,WAAW,GAAG,KAAK,IAAI,WAAW,GAAG,KAAK,MAAM,GAAG;AACxF;AAEA,SAAgB,cAAc,QAAgB,SAAyB;CACrE,OAAO,OAAO,MAAM,GAAG,CAAC,CAAC,KAAI,UAAS;EACpC,MAAM,QAAQ,MAAM,KAAK,CAAC,CAAC,MAAM,KAAK;EAEtC,IAAI,MAAM,MAAM,CAAC,cAAc,MAAM,EAAE,GACrC,MAAM,KAAK,UAAU,MAAM;EAG7B,OAAO,MAAM,KAAK,GAAG;CACvB,CAAC,CAAC,CAAC,KAAK,IAAI;AACd"}

package/dist/utils/watchPaths.d.ts

@@ -0,0 +1,11 @@
+//#region src/utils/watchPaths.d.ts
+/**
+ * Build a predicate that tells whether an absolute file path emitted by
+ * chokidar matches any of the given globs. Patterns are interpreted as
+ * project-relative; a leading `./` is stripped so user-supplied globs like
+ * `./locales/**` behave identically to `locales/**`.
+ */
+declare function createWatchedFileMatcher(patterns: string[], cwd: string): (file: string) => boolean;
+//#endregion
+export { createWatchedFileMatcher };
+//# sourceMappingURL=watchPaths.d.ts.map

package/dist/utils/watchPaths.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"watchPaths.d.ts","names":[],"sources":["../../src/utils/watchPaths.ts"],"mappings":";;AAQA;;;;;iBAAgB,wBAAA,CAAyB,QAAA,YAAoB,GAAA,YAEnD,IAAA"}

package/dist/utils/watchPaths.js

@@ -0,0 +1,19 @@
+import { matchesGlob, relative } from "pathe";
+//#region src/utils/watchPaths.ts
+/**
+* Build a predicate that tells whether an absolute file path emitted by
+* chokidar matches any of the given globs. Patterns are interpreted as
+* project-relative; a leading `./` is stripped so user-supplied globs like
+* `./locales/**` behave identically to `locales/**`.
+*/
+function createWatchedFileMatcher(patterns, cwd) {
+	const normalized = patterns.map((p) => p.replace(/^\.\//, ""));
+	return (file) => {
+		const rel = relative(cwd, file);
+		return normalized.some((p) => matchesGlob(rel, p));
+	};
+}
+//#endregion
+export { createWatchedFileMatcher };
+
+//# sourceMappingURL=watchPaths.js.map

package/dist/utils/watchPaths.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"watchPaths.js","names":[],"sources":["../../src/utils/watchPaths.ts"],"sourcesContent":["import { matchesGlob, relative } from 'pathe'\n\n/**\n * Build a predicate that tells whether an absolute file path emitted by\n * chokidar matches any of the given globs. Patterns are interpreted as\n * project-relative; a leading `./` is stripped so user-supplied globs like\n * `./locales/**` behave identically to `locales/**`.\n */\nexport function createWatchedFileMatcher(patterns: string[], cwd: string) {\n  const normalized = patterns.map(p => p.replace(/^\\.\\//, ''))\n  return (file: string) => {\n    const rel = relative(cwd, file)\n    return normalized.some(p => matchesGlob(rel, p))\n  }\n}\n"],"mappings":";;;;;;;;AAQA,SAAgB,yBAAyB,UAAoB,KAAa;CACxE,MAAM,aAAa,SAAS,KAAI,MAAK,EAAE,QAAQ,SAAS,EAAE,CAAC;CAC3D,QAAQ,SAAiB;EACvB,MAAM,MAAM,SAAS,KAAK,IAAI;EAC9B,OAAO,WAAW,MAAK,MAAK,YAAY,KAAK,CAAC,CAAC;CACjD;AACF"}

package/node_modules/@clack/core/CHANGELOG.md

@@ -1,5 +1,49 @@
 # @clack/core
 
+## 1.4.1
+
+### Patch Changes
+
+- [#548](https://github.com/bombshell-dev/clack/pull/548) [`2356e97`](https://github.com/bombshell-dev/clack/commit/2356e97c1f46007ead55133c3a26910404ef1cfb) Thanks [@43081j](https://github.com/43081j)! - Remove sourcemaps and enable pretty-ish build output.
+
+## 1.4.0
+
+### Minor Changes
+
+- [#543](https://github.com/bombshell-dev/clack/pull/543) [`83428ac`](https://github.com/bombshell-dev/clack/commit/83428ac6d8bc5eda87615cc7b1f14e0c8b16e1b6) Thanks [@florian-lefebvre](https://github.com/florian-lefebvre)! - Adds support for Standard Schema validation
+
+  Prompts accept an optional `validate()` function to validate user input. While a function provides more flexibility and customization over your validation, it can be a bit verbose. To help solve this, there are libraries that provide schema-based validation to make shorthand and type-strict validation substantially easier.
+
+  Libraries following the [Standard Schema specification](https://github.com/standard-schema/standard-schema) are now natively supported. For example, using [Arktype](https://arktype.io/):
+
+  ```diff
+  import { text } from '@clack/prompts';
+  import { type } from 'arktype';
+
+  const name = await text({
+  	message: 'Enter your email',
+  +	validate: type('string.email').describe('Invalid email'),
+  });
+  ```
+
+### Patch Changes
+
+- [#534](https://github.com/bombshell-dev/clack/pull/534) [`3dcb31a`](https://github.com/bombshell-dev/clack/commit/3dcb31a7d63827d95a5a52ac630cbd48e3a68364) Thanks [@MattStypa](https://github.com/MattStypa)! - Fixed spaces and uppercase characters in multiline prompt
+
+## 1.3.1
+
+### Patch Changes
+
+- 54be8d7: Fix line wrapping and overflow computation in group multi-select and other list-like prompts.
+
+## 1.3.0
+
+### Minor Changes
+
+- 78fd3ae: Remove unused `debug` option key.
+- ea5702e: fix: add engines field expressing node >=20.12 requirement
+- 814ab9a: Add new multiline prompt for multi-line text input.
+
 ## 1.2.0
 
 ### Minor Changes

package/node_modules/@clack/core/dist/index.d.mts

@@ -93,14 +93,119 @@ interface ClackEvents<TValue> {
     beforePrompt: () => void;
 }
 
+/** The Standard Schema interface. */
+interface StandardSchemaV1<Input = unknown, Output = Input> {
+    /** The Standard Schema properties. */
+    readonly '~standard': StandardSchemaV1.Props<Input, Output>;
+}
+declare namespace StandardSchemaV1 {
+    /** The Standard Schema properties interface. */
+    interface Props<Input = unknown, Output = Input> {
+        /** The version number of the standard. */
+        readonly version: 1;
+        /** The vendor name of the schema library. */
+        readonly vendor: string;
+        /** Validates unknown input values. */
+        readonly validate: (value: unknown, options?: StandardSchemaV1.Options | undefined) => Result<Output> | Promise<Result<Output>>;
+        /** Inferred types associated with the schema. */
+        readonly types?: Types<Input, Output> | undefined;
+    }
+    /** The result interface of the validate function. */
+    type Result<Output> = SuccessResult<Output> | FailureResult;
+    /** The result interface if validation succeeds. */
+    interface SuccessResult<Output> {
+        /** The typed output value. */
+        readonly value: Output;
+        /** A falsy value for `issues` indicates success. */
+        readonly issues?: undefined;
+    }
+    interface Options {
+        /** Explicit support for additional vendor-specific parameters, if needed. */
+        readonly libraryOptions?: Record<string, unknown> | undefined;
+    }
+    /** The result interface if validation fails. */
+    interface FailureResult {
+        /** The issues of failed validation. */
+        readonly issues: ReadonlyArray<Issue>;
+    }
+    /** The issue interface of the failure output. */
+    interface Issue {
+        /** The error message of the issue. */
+        readonly message: string;
+        /** The path of the issue, if any. */
+        readonly path?: ReadonlyArray<PropertyKey | PathSegment> | undefined;
+    }
+    /** The path segment interface of the issue. */
+    interface PathSegment {
+        /** The key representing a path segment. */
+        readonly key: PropertyKey;
+    }
+    /** The Standard Schema types interface. */
+    interface Types<Input = unknown, Output = Input> {
+        /** The input type of the schema. */
+        readonly input: Input;
+        /** The output type of the schema. */
+        readonly output: Output;
+    }
+    /** Infers the input type of a Standard Schema. */
+    type InferInput<Schema extends StandardSchemaV1> = NonNullable<Schema['~standard']['types']>['input'];
+    /** Infers the output type of a Standard Schema. */
+    type InferOutput<Schema extends StandardSchemaV1> = NonNullable<Schema['~standard']['types']>['output'];
+}
+
+/**
+ * A function or [Standard Schema](https://github.com/standard-schema/standard-schema)
+ * that validates user input. If a custom function is given, you should return a
+ * `string` or `Error` to show as a validation error, or `undefined` to accept the result.
+ *
+ * @example Using arktype
+ * ```ts
+ * import { text } from '@clack/prompts';
+ * import { type } from 'arktype';
+ *
+ * const name = await text({
+ *   message: 'Enter your name (letters only)',
+ *   validate: type('string.alpha').describe('Name can only contain letters'),
+ * });
+ * ```
+ *
+ * @example Custom validator
+ * ```ts
+ * import { text } from '@clack/prompts';
+ *
+ * const age = await text({
+ *   message: 'Enter your age:',
+ *   validate(value) {
+ *     if (!value) return 'Please enter a value';
+ *     const num = parseInt(value);
+ *     if (isNaN(num)) return 'Please enter a valid number';
+ *     if (num < 0 || num > 120) return 'Age must be between 0 and 120';
+ *     return undefined;
+ *   },
+ * });
+ * ```
+ */
+type Validate<TValue> = ((value: TValue | undefined) => string | Error | undefined) | StandardSchemaV1<TValue | undefined, unknown>;
+/**
+ * Runs the `validate()` option and normalizes the result
+ * @param validate - The validate option
+ * @param value - The user input
+ * @returns the validation result
+ */
+declare function runValidation<TValue>(validate: Validate<TValue>, value: TValue | undefined): string | Error | undefined;
+
 interface PromptOptions<TValue, Self extends Prompt<TValue>> {
     render(this: Omit<Self, 'prompt'>): string | undefined;
     initialValue?: any;
     initialUserInput?: string;
-    validate?: ((value: TValue | undefined) => string | Error | undefined) | undefined;
+    /**
+     * A function or a [Standard Schema](https://github.com/standard-schema/standard-schema)
+     * that validates user input. If a custom function is given, you should return a `string` or `Error`
+     * to show as a validation error, or `undefined` to accept the result.
+     */
+    validate?: Validate<TValue> | undefined;
     input?: Readable;
     output?: Writable;
-    debug?: boolean;
     signal?: AbortSignal;
 }
 declare class Prompt<TValue> {
@@ -148,6 +253,7 @@ declare class Prompt<TValue> {
     emit<T extends keyof ClackEvents<TValue>>(event: T, ...data: Parameters<ClackEvents<TValue>[T]>): void;
     prompt(): Promise<symbol | TValue | undefined>;
     protected _isActionKey(char: string | undefined, _key: Key): boolean;
+    protected _shouldSubmit(_char: string | undefined, _key: Key): boolean;
     protected _setValue(value: TValue | undefined): void;
     protected _setUserInput(value: string | undefined, write?: boolean): void;
     protected _clearUserInput(): void;
@@ -258,6 +364,20 @@ declare class GroupMultiSelectPrompt<T extends {
     constructor(opts: GroupMultiSelectOptions<T>);
 }
 
+interface MultiLineOptions extends PromptOptions<string, MultiLinePrompt> {
+    placeholder?: string;
+    defaultValue?: string;
+    showSubmit?: boolean;
+}
+declare class MultiLinePrompt extends Prompt<string> {
+    #private;
+    focused: 'editor' | 'submit';
+    get userInputWithCursor(): string;
+    get cursor(): number;
+    protected _shouldSubmit(_char: string | undefined, _key: Key): boolean;
+    constructor(opts: MultiLineOptions);
+}
+
 interface OptionLike {
     value: any;
     disabled?: boolean;
@@ -343,7 +463,7 @@ interface BlockOptions {
 declare function block({ input, output, overwrite, hideCursor, }?: BlockOptions): () => void;
 declare const getColumns: (output: Writable) => number;
 declare const getRows: (output: Writable) => number;
-declare function wrapTextWithPrefix(output: Writable | undefined, text: string, prefix: string, startPrefix?: string): string;
+declare function wrapTextWithPrefix(output: Writable | undefined, text: string, prefix: string, startPrefix?: string, endPrefix?: string, lineFormatter?: (line: string, index: number) => string): string;
 
-export { AutocompletePrompt, ConfirmPrompt, DatePrompt, GroupMultiSelectPrompt, MultiSelectPrompt, PasswordPrompt, Prompt, SelectKeyPrompt, SelectPrompt, TextPrompt, block, getColumns, getRows, isCancel, settings, updateSettings, wrapTextWithPrefix };
-export type { AutocompleteOptions, ClackSettings, ConfirmOptions, DateFormat, DateOptions, DateParts, GroupMultiSelectOptions, MultiSelectOptions, PasswordOptions, PromptOptions, SelectKeyOptions, SelectOptions, ClackState as State, TextOptions };
+export { AutocompletePrompt, ConfirmPrompt, DatePrompt, GroupMultiSelectPrompt, MultiLinePrompt, MultiSelectPrompt, PasswordPrompt, Prompt, SelectKeyPrompt, SelectPrompt, TextPrompt, block, getColumns, getRows, isCancel, runValidation, settings, updateSettings, wrapTextWithPrefix };
+export type { AutocompleteOptions, ClackSettings, ConfirmOptions, DateFormat, DateOptions, DateParts, GroupMultiSelectOptions, MultiLineOptions, MultiSelectOptions, PasswordOptions, PromptOptions, SelectKeyOptions, SelectOptions, ClackState as State, TextOptions, Validate };