@ai-gui/plugin-form 0.3.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Liang Li
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,42 @@
+# @ai-gui/plugin-form
+
+Safe, framework-neutral interactive forms for AIGUI. React, Vue, and vanilla adapters all host the same DOM mount output.
+
+```ts
+import { ActionRegistry, createActionRuntime } from "@ai-gui/core"
+import { form } from "@ai-gui/plugin-form"
+
+const actions = new ActionRegistry()
+actions.register({
+  type: "travel.search",
+  schema: {
+    type: "object",
+    required: ["from"],
+    properties: { from: { type: "string" } },
+    additionalProperties: false,
+  },
+  run: (params, { signal }) => searchTravel(params, signal),
+})
+
+const plugins = [form({ actionRuntime: createActionRuntime({ registry: actions }) })]
+```
+
+The model may emit:
+
+````md
+```form
+{
+  "id": "travel-search",
+  "fields": [
+    { "name": "from", "type": "text", "label": "From", "required": true },
+    { "name": "date", "type": "date", "label": "Departure" }
+  ],
+  "submitAction": "travel.search",
+  "submitLabel": "Search"
+}
+```
+````
+
+Supported fields are `text`, `textarea`, `number`, `date`, `select`, `checkbox`, and `radio`. Supported constraints are `required`, `minLength`, `maxLength`, `pattern`, `min`, and `max`.
+
+`submitAction` must already exist in the injected `ActionRuntime`. Form JSON rejects unknown properties, HTML, URLs, scripts, event handlers, and dynamic component names. Each mounted form owns its pending state and cancellation scope; adapter teardown aborts only that form's request.

package/dist/index.cjs

@@ -0,0 +1,625 @@
+"use strict";
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+const __ai_gui_core = __toESM(require("@ai-gui/core"));
+
+//#region src/index.ts
+const FIELD_TYPES = new Set([
+	"text",
+	"textarea",
+	"number",
+	"date",
+	"select",
+	"checkbox",
+	"radio"
+]);
+const FORM_KEYS = new Set([
+	"id",
+	"fields",
+	"submitAction",
+	"submitLabel"
+]);
+const FIELD_KEYS = new Set([
+	"name",
+	"type",
+	"label",
+	"required",
+	"minLength",
+	"maxLength",
+	"pattern",
+	"min",
+	"max",
+	"options",
+	"placeholder"
+]);
+const OPTION_KEYS = new Set(["label", "value"]);
+const SAFE_NAME = /^[A-Za-z][A-Za-z0-9_.-]{0,127}$/;
+const SAFE_ID = /^[A-Za-z][A-Za-z0-9_-]{0,127}$/;
+const MAX_SOURCE_LENGTH = 64 * 1024;
+const MAX_FIELDS = 100;
+const MAX_PATTERN_LENGTH = 128;
+let nextFormInstanceId = 0;
+function formPromptSpec() {
+	return [
+		"Forms (fenced): ```form <safe form JSON>```.",
+		"Fields: text, textarea, number, date, select, checkbox, radio. Constraints: required, minLength, maxLength, pattern, min, max.",
+		"submitAction must name an application-registered Action. Never emit URLs, scripts, HTML, handlers, or component names."
+	].join("\n");
+}
+function form(options) {
+	if (!options?.actionRuntime) throw new TypeError("form() requires an actionRuntime");
+	const outputs = new WeakMap();
+	const render = (node) => {
+		const cached = outputs.get(node);
+		if (cached) return cached;
+		if (!node.complete) {
+			const output$1 = {
+				kind: "html",
+				html: "<div data-aigui-block-loading data-block-type=\"form\"></div>"
+			};
+			outputs.set(node, output$1);
+			return output$1;
+		}
+		const parsed = parseFormDefinition(node.content ?? "");
+		if (!parsed.valid) {
+			const output$1 = invalidOutput(parsed.issues);
+			outputs.set(node, output$1);
+			return output$1;
+		}
+		if (!options.actionRuntime.hasAction(parsed.data.submitAction)) {
+			const output$1 = invalidOutput([`Action "${parsed.data.submitAction}" is not registered.`]);
+			outputs.set(node, output$1);
+			return output$1;
+		}
+		const output = {
+			kind: "mount",
+			mount: (host) => mountForm(host, parsed.data, options.actionRuntime)
+		};
+		outputs.set(node, output);
+		return output;
+	};
+	return {
+		name: "form",
+		nodeRenderers: { form: render },
+		promptSpec: formPromptSpec()
+	};
+}
+function parseFormDefinition(source) {
+	if (source.length > MAX_SOURCE_LENGTH) return {
+		valid: false,
+		issues: ["Form definition is too large."]
+	};
+	let value;
+	try {
+		value = JSON.parse(source);
+	} catch {
+		return {
+			valid: false,
+			issues: ["Form definition must be valid JSON."]
+		};
+	}
+	if (!isPlainObject(value)) return {
+		valid: false,
+		issues: ["Form definition must be an object."]
+	};
+	const issues = [];
+	rejectUnknownKeys(value, FORM_KEYS, "$", issues);
+	const id = readString(value.id, "$.id", issues, 128);
+	if (id && !SAFE_ID.test(id)) issues.push("$.id must start with a letter and contain only letters, numbers, underscores, or hyphens.");
+	const submitAction = readString(value.submitAction, "$.submitAction", issues, 256);
+	const submitLabel = value.submitLabel === void 0 ? void 0 : readString(value.submitLabel, "$.submitLabel", issues, 128);
+	if (!Array.isArray(value.fields)) issues.push("$.fields must be an array.");
+	else if (value.fields.length > MAX_FIELDS) issues.push(`$.fields must contain at most ${MAX_FIELDS} fields.`);
+	const fields = [];
+	const names = new Set();
+	if (Array.isArray(value.fields)) value.fields.forEach((candidate, index) => {
+		const field = parseField(candidate, index, issues);
+		if (!field) return;
+		if (names.has(field.name)) issues.push(`$.fields[${index}].name must be unique.`);
+		names.add(field.name);
+		fields.push(field);
+	});
+	if (issues.length > 0 || !id || !submitAction) return {
+		valid: false,
+		issues
+	};
+	return {
+		valid: true,
+		data: {
+			id,
+			fields,
+			submitAction,
+			...submitLabel === void 0 ? {} : { submitLabel }
+		}
+	};
+}
+function validateFormValues(definition, input) {
+	const values = Object.create(null);
+	const errors = Object.create(null);
+	for (const field of definition.fields) {
+		const raw = input[field.name];
+		if (field.type === "checkbox") {
+			const value$1 = raw === true;
+			values[field.name] = value$1;
+			if (field.required && !value$1) errors[field.name] = "This field is required.";
+			continue;
+		}
+		if (field.type === "number") {
+			if (raw === "" || raw === void 0 || raw === null) {
+				if (field.required) errors[field.name] = "This field is required.";
+				continue;
+			}
+			const value$1 = typeof raw === "number" ? raw : Number(raw);
+			if (!Number.isFinite(value$1)) {
+				errors[field.name] = "Must be a number.";
+				continue;
+			}
+			values[field.name] = value$1;
+			if (field.min !== void 0 && value$1 < field.min) errors[field.name] = `Must be at least ${field.min}.`;
+			else if (field.max !== void 0 && value$1 > field.max) errors[field.name] = `Must be at most ${field.max}.`;
+			continue;
+		}
+		const value = typeof raw === "string" ? raw : "";
+		if (value === "") {
+			if (field.required) errors[field.name] = "This field is required.";
+			continue;
+		}
+		values[field.name] = value;
+		if (field.type === "select" || field.type === "radio") {
+			if (!field.options.some((option) => option.value === value)) errors[field.name] = "Select an allowed option.";
+			continue;
+		}
+		if (field.type === "date") continue;
+		if ("minLength" in field && field.minLength !== void 0 && value.length < field.minLength) errors[field.name] = `Must contain at least ${field.minLength} characters.`;
+		else if ("maxLength" in field && field.maxLength !== void 0 && value.length > field.maxLength) errors[field.name] = `Must contain at most ${field.maxLength} characters.`;
+		else if ("pattern" in field && field.pattern !== void 0 && !new RegExp(field.pattern).test(value)) errors[field.name] = "Must match the required format.";
+	}
+	return {
+		valid: Object.keys(errors).length === 0,
+		values,
+		errors
+	};
+}
+function parseField(value, index, issues) {
+	const path = `$.fields[${index}]`;
+	if (!isPlainObject(value)) {
+		issues.push(`${path} must be an object.`);
+		return void 0;
+	}
+	rejectUnknownKeys(value, FIELD_KEYS, path, issues);
+	const name = readString(value.name, `${path}.name`, issues, 128);
+	const label = readString(value.label, `${path}.label`, issues, 256);
+	const rawType = readString(value.type, `${path}.type`, issues, 32);
+	const type = rawType && FIELD_TYPES.has(rawType) ? rawType : void 0;
+	if (name && !SAFE_NAME.test(name)) issues.push(`${path}.name is not a safe field name.`);
+	if (rawType && !type) issues.push(`${path}.type is not supported.`);
+	if (value.required !== void 0 && typeof value.required !== "boolean") issues.push(`${path}.required must be a boolean.`);
+	const placeholder = value.placeholder === void 0 ? void 0 : readString(value.placeholder, `${path}.placeholder`, issues, 256);
+	const minLength = readOptionalInteger(value.minLength, `${path}.minLength`, issues);
+	const maxLength = readOptionalInteger(value.maxLength, `${path}.maxLength`, issues);
+	const min = readOptionalNumber(value.min, `${path}.min`, issues);
+	const max = readOptionalNumber(value.max, `${path}.max`, issues);
+	if (minLength !== void 0 && maxLength !== void 0 && minLength > maxLength) issues.push(`${path}.minLength cannot exceed maxLength.`);
+	if (min !== void 0 && max !== void 0 && min > max) issues.push(`${path}.min cannot exceed max.`);
+	let pattern;
+	if (value.pattern !== void 0) {
+		pattern = readString(value.pattern, `${path}.pattern`, issues, MAX_PATTERN_LENGTH);
+		if (pattern !== void 0) if (!isSafePattern(pattern)) issues.push(`${path}.pattern uses unsupported regular expression features.`);
+		else try {
+			new RegExp(pattern);
+		} catch {
+			issues.push(`${path}.pattern must be a valid regular expression.`);
+		}
+	}
+	if (!name || !label || !type) return void 0;
+	const base = {
+		name,
+		label,
+		...value.required === true ? { required: true } : {},
+		...placeholder === void 0 ? {} : { placeholder }
+	};
+	if (type === "number") {
+		if (minLength !== void 0 || maxLength !== void 0 || pattern !== void 0 || value.options !== void 0) issues.push(`${path} contains constraints unsupported by number fields.`);
+		return {
+			...base,
+			type,
+			...min === void 0 ? {} : { min },
+			...max === void 0 ? {} : { max }
+		};
+	}
+	if (type === "select" || type === "radio") {
+		if (minLength !== void 0 || maxLength !== void 0 || pattern !== void 0 || min !== void 0 || max !== void 0 || placeholder !== void 0) issues.push(`${path} contains unsupported choice-field properties.`);
+		const options = parseOptions(value.options, `${path}.options`, issues);
+		return {
+			...base,
+			type,
+			options
+		};
+	}
+	if (type === "checkbox") {
+		if (minLength !== void 0 || maxLength !== void 0 || pattern !== void 0 || min !== void 0 || max !== void 0 || value.options !== void 0 || placeholder !== void 0) issues.push(`${path} contains unsupported checkbox properties.`);
+		return {
+			...base,
+			type
+		};
+	}
+	if (type === "date") {
+		if (minLength !== void 0 || maxLength !== void 0 || pattern !== void 0 || min !== void 0 || max !== void 0 || value.options !== void 0 || placeholder !== void 0) issues.push(`${path} contains unsupported date-field properties.`);
+		return {
+			...base,
+			type
+		};
+	}
+	if (min !== void 0 || max !== void 0 || value.options !== void 0) issues.push(`${path} contains unsupported string-field properties.`);
+	return {
+		...base,
+		type,
+		...minLength === void 0 ? {} : { minLength },
+		...maxLength === void 0 ? {} : { maxLength },
+		...pattern === void 0 ? {} : { pattern }
+	};
+}
+function parseOptions(value, path, issues) {
+	if (!Array.isArray(value) || value.length === 0 || value.length > 100) {
+		issues.push(`${path} must be a non-empty array with at most 100 options.`);
+		return [];
+	}
+	const seen = new Set();
+	return value.flatMap((option, index) => {
+		const itemPath = `${path}[${index}]`;
+		if (!isPlainObject(option)) {
+			issues.push(`${itemPath} must be an object.`);
+			return [];
+		}
+		rejectUnknownKeys(option, OPTION_KEYS, itemPath, issues);
+		const label = readString(option.label, `${itemPath}.label`, issues, 256);
+		const optionValue = readString(option.value, `${itemPath}.value`, issues, 256);
+		if (optionValue !== void 0 && seen.has(optionValue)) issues.push(`${itemPath}.value must be unique.`);
+		if (optionValue !== void 0) seen.add(optionValue);
+		return label !== void 0 && optionValue !== void 0 ? [{
+			label,
+			value: optionValue
+		}] : [];
+	});
+}
+function mountForm(host, definition, runtime) {
+	const instanceId = String(++nextFormInstanceId);
+	const instancePrefix = `aigui-form-${instanceId}-${definition.id}`;
+	const cardType = `form:${definition.id}:${instanceId}`;
+	const owner = {};
+	const controller = new AbortController();
+	let pending = false;
+	let disposed = false;
+	const formElement = document.createElement("form");
+	formElement.noValidate = true;
+	formElement.setAttribute("data-aigui-form", definition.id);
+	formElement.setAttribute("data-aigui-form-instance", instanceId);
+	const controls = new Map();
+	const errorElements = new Map();
+	for (const field of definition.fields) {
+		const rendered = createField(instancePrefix, field);
+		formElement.appendChild(rendered.container);
+		controls.set(field.name, rendered.control);
+		errorElements.set(field.name, rendered.error);
+	}
+	const actionError = document.createElement("div");
+	actionError.setAttribute("data-aigui-form-action-error", "");
+	actionError.setAttribute("role", "alert");
+	actionError.hidden = true;
+	formElement.appendChild(actionError);
+	const submit = document.createElement("button");
+	submit.type = "submit";
+	submit.textContent = definition.submitLabel ?? "Submit";
+	formElement.appendChild(submit);
+	const onInput = (event) => {
+		const control = event.target;
+		if (!(control instanceof HTMLInputElement || control instanceof HTMLTextAreaElement || control instanceof HTMLSelectElement)) return;
+		clearFieldError(control.name, controls, errorElements);
+		actionError.hidden = true;
+	};
+	const onSubmit = (event) => {
+		event.preventDefault();
+		if (pending || disposed) return;
+		const validation = validateFormValues(definition, readControls(definition, controls));
+		renderErrors(validation.errors, controls, errorElements);
+		actionError.hidden = true;
+		if (!validation.valid) {
+			controls.get(Object.keys(validation.errors)[0])?.focus();
+			return;
+		}
+		pending = true;
+		submit.disabled = true;
+		formElement.setAttribute("aria-busy", "true");
+		const settle = () => {
+			if (disposed) return;
+			pending = false;
+			submit.disabled = false;
+			formElement.removeAttribute("aria-busy");
+		};
+		runtime.dispatch({
+			type: definition.submitAction,
+			params: validation.values,
+			cardType
+		}, {
+			owner,
+			signal: controller.signal
+		}).then(settle, (error) => {
+			if (!disposed && !controller.signal.aborted) {
+				actionError.textContent = actionErrorMessage(error);
+				actionError.hidden = false;
+			}
+			settle();
+		});
+	};
+	formElement.addEventListener("input", onInput);
+	formElement.addEventListener("change", onInput);
+	formElement.addEventListener("submit", onSubmit);
+	host.replaceChildren(formElement);
+	return () => {
+		disposed = true;
+		controller.abort();
+		formElement.removeEventListener("input", onInput);
+		formElement.removeEventListener("change", onInput);
+		formElement.removeEventListener("submit", onSubmit);
+	};
+}
+function createField(formId, field) {
+	const container = document.createElement(field.type === "radio" ? "fieldset" : "div");
+	container.setAttribute("data-aigui-form-field", field.name);
+	const controlId = `${formId}-${field.name.replace(/[^A-Za-z0-9_-]/g, "-")}`;
+	const errorId = `${controlId}-error`;
+	const error = document.createElement("div");
+	error.id = errorId;
+	error.setAttribute("data-aigui-form-field-error", field.name);
+	error.setAttribute("aria-live", "polite");
+	error.hidden = true;
+	if (field.type === "radio") {
+		const legend = document.createElement("legend");
+		legend.textContent = field.label;
+		container.appendChild(legend);
+		let first;
+		for (const [index, option] of field.options.entries()) {
+			const optionId = `${controlId}-${index}`;
+			const input = document.createElement("input");
+			input.type = "radio";
+			input.id = optionId;
+			input.name = field.name;
+			input.value = option.value;
+			input.required = field.required === true;
+			input.setAttribute("aria-describedby", errorId);
+			const label$1 = document.createElement("label");
+			label$1.htmlFor = optionId;
+			label$1.textContent = option.label;
+			container.append(input, label$1);
+			first ??= input;
+		}
+		container.appendChild(error);
+		return {
+			container,
+			control: first,
+			error
+		};
+	}
+	let control;
+	if (field.type === "textarea") control = document.createElement("textarea");
+	else if (field.type === "select") {
+		const select = document.createElement("select");
+		const empty = document.createElement("option");
+		empty.value = "";
+		empty.textContent = "Select...";
+		select.appendChild(empty);
+		for (const option of field.options) {
+			const element = document.createElement("option");
+			element.value = option.value;
+			element.textContent = option.label;
+			select.appendChild(element);
+		}
+		control = select;
+	} else {
+		const input = document.createElement("input");
+		input.type = field.type;
+		control = input;
+	}
+	control.id = controlId;
+	control.setAttribute("name", field.name);
+	control.required = field.required === true;
+	control.setAttribute("aria-describedby", errorId);
+	if (field.placeholder !== void 0 && !(control instanceof HTMLSelectElement)) control.placeholder = field.placeholder;
+	if ((control instanceof HTMLInputElement || control instanceof HTMLTextAreaElement) && (field.type === "text" || field.type === "textarea") && field.minLength !== void 0) control.minLength = field.minLength;
+	if ((control instanceof HTMLInputElement || control instanceof HTMLTextAreaElement) && (field.type === "text" || field.type === "textarea") && field.maxLength !== void 0) control.maxLength = field.maxLength;
+	if (field.type === "text" && field.pattern !== void 0 && control instanceof HTMLInputElement) control.pattern = field.pattern;
+	if (field.type === "number" && control instanceof HTMLInputElement) {
+		if (field.min !== void 0) control.min = String(field.min);
+		if (field.max !== void 0) control.max = String(field.max);
+	}
+	const label = document.createElement("label");
+	label.htmlFor = controlId;
+	label.textContent = field.label;
+	if (field.type === "checkbox") container.append(control, label, error);
+	else container.append(label, control, error);
+	return {
+		container,
+		control,
+		error
+	};
+}
+function readControls(definition, controls) {
+	const values = Object.create(null);
+	for (const field of definition.fields) {
+		const control = controls.get(field.name);
+		if (!control) continue;
+		if (field.type === "checkbox" && control instanceof HTMLInputElement) values[field.name] = control.checked;
+		else if (field.type === "radio") {
+			const group = control.form?.elements.namedItem(field.name);
+			values[field.name] = group instanceof RadioNodeList ? group.value : control instanceof HTMLInputElement && control.checked ? control.value : "";
+		} else values[field.name] = control.value;
+	}
+	return values;
+}
+function renderErrors(errors, controls, elements) {
+	for (const name of controls.keys()) {
+		const message = errors[name];
+		const control = controls.get(name);
+		const element = elements.get(name);
+		if (!control || !element) continue;
+		if (message) {
+			control.setAttribute("aria-invalid", "true");
+			element.textContent = message;
+			element.hidden = false;
+		} else clearFieldError(name, controls, elements);
+	}
+}
+function clearFieldError(name, controls, elements) {
+	controls.get(name)?.removeAttribute("aria-invalid");
+	const element = elements.get(name);
+	if (element) {
+		element.textContent = "";
+		element.hidden = true;
+	}
+}
+function invalidOutput(issues) {
+	return {
+		kind: "html",
+		html: `<div data-aigui-form-invalid="" role="alert">${escapeHtml(issues[0] ?? "Invalid form definition.")}</div>`
+	};
+}
+function actionErrorMessage(error) {
+	return error instanceof __ai_gui_core.ActionRuntimeError ? error.message : "The action failed.";
+}
+function rejectUnknownKeys(value, allowed, path, issues) {
+	for (const key of Object.keys(value)) if (!allowed.has(key)) issues.push(`${path}.${key} is not allowed.`);
+}
+function readString(value, path, issues, maxLength, allowEmpty = false) {
+	if (typeof value !== "string" || !allowEmpty && value.trim() === "" || value.length > maxLength) {
+		issues.push(`${path} must be ${allowEmpty ? "a" : "a non-empty"} string of at most ${maxLength} characters.`);
+		return void 0;
+	}
+	return value;
+}
+function readOptionalInteger(value, path, issues) {
+	if (value === void 0) return void 0;
+	if (!Number.isInteger(value) || value < 0 || value > 1e6) {
+		issues.push(`${path} must be a non-negative integer.`);
+		return void 0;
+	}
+	return value;
+}
+function readOptionalNumber(value, path, issues) {
+	if (value === void 0) return void 0;
+	if (typeof value !== "number" || !Number.isFinite(value)) {
+		issues.push(`${path} must be a finite number.`);
+		return void 0;
+	}
+	return value;
+}
+function isPlainObject(value) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+	const prototype = Object.getPrototypeOf(value);
+	return prototype === Object.prototype || prototype === null;
+}
+function escapeHtml(value) {
+	return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+function isSafePattern(pattern) {
+	let index = 0;
+	let hasAtom = false;
+	let canQuantify = false;
+	let hasQuantifier = false;
+	if (pattern[index] === "^") index++;
+	while (index < pattern.length) {
+		const char = pattern[index];
+		if (char === "$" && index === pattern.length - 1) return hasAtom;
+		if (char === "[") {
+			const end = readCharacterClass(pattern, index);
+			if (end === -1) return false;
+			index = end;
+			hasAtom = true;
+			canQuantify = true;
+			continue;
+		}
+		if (char === "\\") {
+			if (!isSafeEscape(pattern[index + 1])) return false;
+			index += 2;
+			hasAtom = true;
+			canQuantify = true;
+			continue;
+		}
+		if (char === "*" || char === "+" || char === "?") {
+			if (!canQuantify || hasQuantifier) return false;
+			index++;
+			canQuantify = false;
+			hasQuantifier = true;
+			continue;
+		}
+		if (char === "{") {
+			if (!canQuantify || hasQuantifier) return false;
+			const end = readBoundedQuantifier(pattern, index);
+			if (end === -1) return false;
+			index = end;
+			canQuantify = false;
+			hasQuantifier = true;
+			continue;
+		}
+		if (".^$|()]}".includes(char)) return false;
+		index++;
+		hasAtom = true;
+		canQuantify = true;
+	}
+	return hasAtom;
+}
+function readCharacterClass(pattern, start) {
+	let index = start + 1;
+	if (pattern[index] === "^") index++;
+	let hasCharacter = false;
+	while (index < pattern.length) {
+		const char = pattern[index];
+		if (char === "]") return hasCharacter ? index + 1 : -1;
+		if (char === "\\") {
+			if (!isSafeEscape(pattern[index + 1])) return -1;
+			index += 2;
+		} else {
+			if (char === "[") return -1;
+			index++;
+		}
+		hasCharacter = true;
+	}
+	return -1;
+}
+function readBoundedQuantifier(pattern, start) {
+	const match = /^\{(\d{1,4})(?:,(\d{0,4}))?\}/.exec(pattern.slice(start));
+	if (!match) return -1;
+	const minimum = Number(match[1]);
+	const maximum = match[2] === void 0 || match[2] === "" ? minimum : Number(match[2]);
+	if (minimum > 1e3 || maximum > 1e3 || maximum < minimum) return -1;
+	return start + match[0].length;
+}
+function isSafeEscape(char) {
+	return char !== void 0 && ("dDsSwW\\.^$*+?{}[]|()-".includes(char) || !/[A-Za-z0-9]/.test(char));
+}
+
+//#endregion
+exports.form = form
+exports.formPromptSpec = formPromptSpec
+exports.parseFormDefinition = parseFormDefinition
+exports.validateFormValues = validateFormValues