@menapo/forms 0.0.0-stage → 0.1.0

package/dist/instance-C1aijv06.js

@@ -0,0 +1,683 @@
+import { a as nameOf, i as merge, n as get, o as patternOf, r as leaves, s as set, t as equal } from "./paths-DqNafpnl.js";
+import { liveRegion } from "@menapo/machine/dom";
+//#region src/core/env.ts
+/**
+* What every form shares (PLAN §6.2): development checks, the error format
+* and the nullable DevTools hook (D18). One module, so `inspect` and the
+* tests reach the hook without a second copy.
+*/
+/**
+* Development checks and messages: Vite replaces `import.meta.env.DEV` with
+* a literal, so a production build drops every `if (DEV)` branch. Without
+* Vite, `env` is undefined and the checks are off.
+*/
+const DEV = !!import.meta.env?.DEV;
+/** `[forms:CODE] message`: an error that names what went wrong and the fix. */
+const fail = (code, text) => /* @__PURE__ */ new Error(`[forms:${code}] ${text}`);
+/** A development warning, in the same format. */
+const warn = (code, text) => console.warn(`[forms:${code}] ${text}`);
+const env = { server: typeof document === "undefined" };
+/** One field: its error, flags and cached parts. Values live in the instance's tree. */
+var Rec = class {
+	/** Its path: renamed when an array moves its item (D14). */
+	p;
+	e = void 0;
+	s = 0;
+	t = false;
+	/** Checks or async validations running. */
+	vd = 0;
+	/** A view read the hint: it is rendered, so the control links it. */
+	h = false;
+	/** A view asked for it, or the DOM has its control: issues at its path are its own. */
+	k = false;
+	/** Moves with what the parts show. */
+	ver = 0;
+	pc = void 0;
+	pv = -1;
+	oc = void 0;
+	constructor(path) {
+		this.p = path;
+	}
+};
+const byId = (id) => typeof document === "object" ? document.getElementById(id) : null;
+/** Each path and its ancestors: a change to `invites.0.email` is one to `invites` too. */
+function withParents(path) {
+	const out = [path];
+	for (let at = path.lastIndexOf("."); at > 0; at = path.lastIndexOf(".", at - 1)) out.push(path.slice(0, at));
+	return out;
+}
+var Instance = class {
+	F;
+	/** The DOM id the form's ids derive from. */
+	id;
+	N;
+	/** Values: an immutable tree (paths.ts). */
+	v;
+	/** What `dirty` compares against: the defaults, then the last success's values. */
+	b;
+	/** The merged defaults (D11). */
+	d;
+	/** The hook's own `defaults`, as last given: a new object is followed. */
+	hd;
+	r = /* @__PURE__ */ new Map();
+	/** Paths whose value differs from the baseline. */
+	dp = /* @__PURE__ */ new Set();
+	ls = [];
+	onSuccess;
+	pending = false;
+	error = void 0;
+	/** The form error came from the schema (an issue with no field), so a valid run clears it. */
+	ce = false;
+	data = void 0;
+	progress = 0;
+	/** A submit was attempted: errors now update on input and blur (D8). */
+	at = false;
+	/** The order of paths in the last issues, for `errors`. */
+	ord = [];
+	/** `errors`, cached until an error changes. */
+	ec = void 0;
+	/** Full validations started; a result for an older one is dropped. */
+	vv = 0;
+	ac = void 0;
+	/** After the next commit: focus the summary or the first invalid control (D12). */
+	fo = false;
+	/** Messages to announce after the next commit. */
+	an = [];
+	/** Inside a submit: errors are announced by focus, not the live region. */
+	inSubmit = false;
+	mounted = false;
+	/** The form parts, cached by `pending`. */
+	fp = void 0;
+	/** The delegated handlers, made with the first parts so their identity never changes (D6). */
+	hs = void 0;
+	fpv = void 0;
+	/** The array module's stable keys, by array path (D14). */
+	ak = void 0;
+	/** The checks module's state (D8). */
+	ck = void 0;
+	/** The definition's shape, once these values extended it (view.ts). */
+	sh = void 0;
+	constructor(F, id, N, options) {
+		this.F = F;
+		this.id = id;
+		this.N = N;
+		this.hd = options?.defaults;
+		this.onSuccess = options?.onSuccess;
+		this.d = merge(F.o.defaults, options?.defaults);
+		this.v = this.b = this.d;
+		const state = options?.state;
+		if (state) {
+			this.v = merge(this.v, state.values);
+			for (const [path, message] of Object.entries(state.errors)) {
+				const rec = this.rec(path);
+				rec.e = message;
+				rec.s = 1;
+				this.ord.push(path);
+			}
+			for (const [path] of leaves(this.v)) this.dirty(path);
+			if (state.error) this.error = new Error(state.error);
+			this.at = true;
+		}
+	}
+	rec(path) {
+		let rec = this.r.get(path);
+		if (!rec) this.r.set(path, rec = new Rec(path));
+		return rec;
+	}
+	spec(path) {
+		return this.F.f[patternOf(path)];
+	}
+	fid(path) {
+		return `${this.id}-${path}`;
+	}
+	tell(paths, mask, form) {
+		if (form & 4) this.ec = void 0;
+		for (const listener of this.ls) listener.hear(paths, mask, form);
+		if (DEV) env.devtools?.({
+			kind: "change",
+			instance: this
+		});
+	}
+	/** Every view moves: a reset, new defaults. */
+	all() {
+		this.ec = void 0;
+		for (const rec of this.r.values()) rec.ver++;
+		this.tell([...this.r.keys(), ...withParents("")], -1, -1);
+	}
+	/** Recomputes whether `path` is dirty; the form's bit when the set changed size between empty and not. */
+	dirty(path) {
+		const was = this.dp.size;
+		if (equal(get(this.v, path), get(this.b, path))) this.dp.delete(path);
+		else this.dp.add(path);
+		return !was !== !this.dp.size ? 8 : 0;
+	}
+	/** Writes a value: from the DOM (`dom`), or from code, which also writes the control. */
+	set(path, value, dom) {
+		if (equal(get(this.v, path), value)) return;
+		this.v = set(this.v, path, value);
+		const rec = this.rec(path);
+		let mask = 1;
+		const wasDirty = this.dp.has(path);
+		let form = this.dirty(path);
+		if (wasDirty !== this.dp.has(path)) mask |= 8;
+		if (rec.s === 1) {
+			this.error_(rec, void 0, 0);
+			mask |= 34;
+			form |= 4;
+		}
+		if (!dom) this.#write(path, value);
+		this.tell(withParents(path), mask, form);
+		if (Array.isArray(value)) this.tell([path], 64, 0);
+		if (this.at && rec.e !== void 0) this.#validate(path);
+		this.F.c?.run(this, path, value);
+	}
+	/** A control's event (D6): its value by its type and the field's spec. */
+	#input(el) {
+		const path = el.name;
+		if (!path || !("form" in el)) return;
+		this.rec(path).k = true;
+		if (el.type === "radio" && !el.checked) return;
+		this.set(path, this.#read(el), true);
+	}
+	#read(el) {
+		const path = el.name;
+		const spec = this.spec(path);
+		const input = el;
+		switch (input.type) {
+			case "checkbox": {
+				if (spec?.t !== "array" && !Array.isArray(get(this.v, path))) return input.checked;
+				const all = input.form?.elements.namedItem(path);
+				return (all && "length" in all ? [...all] : [input]).filter((b) => b.checked).map((b) => b.value);
+			}
+			case "file": return spec?.m ? [...input.files ?? []] : input.files?.[0] ?? void 0;
+			case "select-multiple": return [...el.selectedOptions].map((o) => o.value);
+		}
+		const text = el.value;
+		if (spec?.t === "number" || spec?.t === "integer" || input.type === "number") return text === "" ? void 0 : Number.isNaN(Number(text)) ? text : Number(text);
+		return text;
+	}
+	/** Writes `value` into the controls named `path` (S4): a set, a reset, defaults followed. */
+	#write(path, value) {
+		const found = byId(this.id)?.elements.namedItem(path) ?? byId(this.fid(path));
+		if (!found) return;
+		const els = "length" in found && !("type" in found) ? [...found] : [found];
+		for (const el of els) {
+			const input = el;
+			if (input.type === "checkbox") input.checked = Array.isArray(value) ? value.includes(input.value) : value === true;
+			else if (input.type === "radio") input.checked = value != null && String(value) === input.value;
+			else if (input.type === "file") {
+				if (value == null) input.value = "";
+			} else if (input.type === "select-multiple") for (const option of el.options) option.selected = Array.isArray(value) && value.includes(option.value);
+			else el.value = value == null ? "" : String(value);
+		}
+	}
+	blur(el) {
+		const path = el.name;
+		if (!path) return;
+		const rec = this.rec(path);
+		rec.k = true;
+		if (!rec.t) {
+			rec.t = true;
+			this.tell([path], 4, 0);
+		}
+		if (this.at) this.#validate(path);
+	}
+	/** Sets a field's error: one place, so the live region and the summary follow every change. */
+	error_(rec, message, source) {
+		if (rec.e === message) {
+			if (message !== void 0) rec.s = source;
+			return false;
+		}
+		rec.e = message;
+		rec.s = message === void 0 ? 0 : source;
+		rec.ver++;
+		if (message !== void 0 && !this.inSubmit && typeof document === "object") {
+			const control = byId(this.fid(rec.p));
+			if (document.activeElement !== control) this.an.push(message);
+		}
+		return true;
+	}
+	/** Field errors from issues; those with no field become the form's error. */
+	#apply(issues, only, source) {
+		const found = /* @__PURE__ */ new Map();
+		const order = [];
+		for (const issue of issues) {
+			const path = nameOf(issue.path);
+			let message = issue.message;
+			if (typeof message !== "string") {
+				if (DEV) warn("MESSAGE_NOT_TEXT", `${path || this.F.n}: the schema's message is a msg() reference; word it where it runs: v.minLength(1, () => t("Name is required.")).`);
+				message = String(message);
+			}
+			if (!found.has(path)) {
+				found.set(path, message);
+				order.push(path);
+			}
+		}
+		const paths = [];
+		if (only !== void 0) {
+			const rec = this.rec(only);
+			const message = found.get(only);
+			if ((message !== void 0 || rec.s !== 1) && this.error_(rec, message, source)) paths.push(only);
+		} else {
+			const unmatched = [];
+			for (const rec of this.r.values()) {
+				const message = found.get(rec.p);
+				if (message === void 0 && rec.s === 1 && source === 0) continue;
+				if (this.error_(rec, message, source)) paths.push(rec.p);
+			}
+			for (const [path, message] of found) {
+				if (this.r.has(path)) continue;
+				if (path && this.#known(path)) {
+					const rec = this.rec(path);
+					rec.k = true;
+					if (this.error_(rec, message, source)) paths.push(path);
+				} else unmatched.push(message);
+			}
+			this.ord = order;
+			if (source === 0) {
+				if (unmatched.length) {
+					this.error = Object.assign(new Error(unmatched.join(" ")), { issues });
+					this.ce = true;
+				} else if (this.ce) {
+					this.error = void 0;
+					this.ce = false;
+				}
+			}
+			if (paths.length || unmatched.length) this.tell(paths, 34, 6);
+			return found.size > 0;
+		}
+		if (paths.length) this.tell(paths, 34, 4);
+		return found.has(only);
+	}
+	/** Whether the DOM has a control named `path`. */
+	#known(path) {
+		return !!byId(this.id)?.elements.namedItem(path);
+	}
+	/**
+	* Validates one field's error, after input or blur (D8). An async schema
+	* resolves later; a result for a value since replaced is dropped.
+	*/
+	#validate(only) {
+		const schema = this.F.s;
+		if (!schema) return false;
+		const version = ++this.vv;
+		const result = schema["~standard"].validate(this.v);
+		const done = (r) => version === this.vv && this.#apply(r.issues ?? [], only, 0);
+		if (!("then" in result)) return done(result);
+		const rec = this.rec(only);
+		if (!rec.vd++) this.tell([only], 16, 0);
+		return result.then((r) => {
+			if (!--rec.vd) this.tell([only], 16, 0);
+			return done(r);
+		});
+	}
+	async submit() {
+		if (this.pending || this.inSubmit) return void 0;
+		this.at = true;
+		this.inSubmit = true;
+		const start = DEV ? performance.now() : 0;
+		try {
+			await this.F.c?.settle(this);
+			const schema = this.F.s;
+			let output = this.v;
+			let invalid = false;
+			if (schema) {
+				const version = ++this.vv;
+				let result = schema["~standard"].validate(this.v);
+				if ("then" in result) result = await result;
+				if (version === this.vv) this.#apply(result.issues ?? [], void 0, 0);
+				if (result.issues) invalid = true;
+				else output = result.value;
+			}
+			for (const rec of this.r.values()) if (rec.e !== void 0) invalid = true;
+			if (invalid || this.ce && this.error !== void 0) {
+				this.fo = true;
+				this.tell([], 0, 4);
+				return;
+			}
+			const input = this.v;
+			this.ac?.abort();
+			const controller = this.ac = new AbortController();
+			this.#flags(true, void 0, 0);
+			try {
+				const data = await this.F.x(this.F, input, output, {
+					signal: controller.signal,
+					progress: (ratio) => this.#flags(true, void 0, ratio)
+				});
+				if (controller.signal.aborted) return void 0;
+				this.#succeed(input, data);
+				if (DEV) env.devtools?.({
+					kind: "submit",
+					instance: this,
+					ms: performance.now() - start
+				});
+				this.onSuccess?.(data);
+				return data;
+			} catch (error) {
+				if (controller.signal.aborted) return void 0;
+				if (DEV) env.devtools?.({
+					kind: "submit",
+					instance: this,
+					ms: performance.now() - start,
+					error
+				});
+				this.#fail_(error);
+				return;
+			} finally {
+				if (this.ac === controller) this.ac = void 0;
+			}
+		} finally {
+			this.inSubmit = false;
+		}
+	}
+	#flags(pending, error, progress) {
+		const form = (pending !== this.pending ? 1 : 0) | (error !== this.error ? 2 : 0) | (progress !== this.progress ? 32 : 0);
+		this.pending = pending;
+		this.error = error;
+		this.progress = progress;
+		if (form) this.tell([], 0, form);
+	}
+	#succeed(input, data) {
+		this.b = input;
+		this.at = false;
+		this.data = data;
+		const paths = [];
+		for (const rec of this.r.values()) {
+			if (this.error_(rec, void 0, 0)) paths.push(rec.p);
+			rec.ver++;
+		}
+		this.dp.clear();
+		for (const [path] of leaves(this.v)) this.dirty(path);
+		this.ce = false;
+		this.pending = false;
+		this.error = void 0;
+		this.tell([...this.r.keys()], 42, -1);
+	}
+	/** A failed submit: `issues` on their fields, the rest the form's error (D9). */
+	#fail_(error) {
+		const issues = error?.issues;
+		let matched = false;
+		if (Array.isArray(issues) && issues.length) {
+			this.ce = false;
+			for (const rec of this.r.values()) if (rec.s === 1) this.error_(rec, void 0, 0);
+			const unmatched = issues.filter((issue) => {
+				const path = nameOf(issue.path);
+				return !path || !(this.r.get(path)?.k || this.#known(path));
+			});
+			this.#apply(issues.filter((issue) => !unmatched.includes(issue)), void 0, 1);
+			matched = unmatched.length < issues.length;
+			this.#flags(false, unmatched.length ? error : void 0, this.progress);
+		} else this.#flags(false, error, this.progress);
+		if (matched) this.fo = true;
+		this.tell([], 0, 4);
+	}
+	reset(values) {
+		this.ac?.abort();
+		this.v = this.b = values === void 0 ? this.d : merge(this.d, values);
+		this.dp.clear();
+		this.at = this.ce = this.pending = false;
+		this.error = void 0;
+		this.progress = 0;
+		this.ord = [];
+		for (const rec of this.r.values()) {
+			rec.e = void 0;
+			rec.s = 0;
+			rec.t = false;
+		}
+		this.ak = void 0;
+		this.#writeAll();
+		this.all();
+	}
+	/** Every named control gets its value (a reset, a new baseline). */
+	#writeAll() {
+		const form = byId(this.id);
+		const done = /* @__PURE__ */ new Set();
+		for (const el of form ? [...form.elements] : []) {
+			const name = el.name;
+			if (!name || done.has(name) || el.type === "submit") continue;
+			done.add(name);
+			this.#write(name, get(this.v, name));
+		}
+	}
+	/** The hook's options again (D11): pristine fields follow new defaults; edited ones keep their text. */
+	options(options) {
+		this.onSuccess = options?.onSuccess;
+		if (options?.defaults === this.hd) return;
+		this.hd = options?.defaults;
+		const next = merge(this.F.o.defaults, options?.defaults);
+		if (equal(next, this.d)) return;
+		const old = this.b;
+		let values = this.v;
+		const written = [];
+		for (const [path, value] of leaves(next)) if (equal(get(values, path), get(old, path)) && !equal(get(values, path), value)) {
+			values = set(values, path, value);
+			written.push([path, value]);
+		}
+		this.d = next;
+		this.b = next;
+		this.v = values;
+		this.dp.clear();
+		for (const [path] of leaves(values)) this.dirty(path);
+		for (const [path, value] of written) this.#write(path, value);
+		this.all();
+	}
+	mount() {
+		if (this.mounted || env.server) return;
+		this.mounted = true;
+		if (DEV) env.devtools?.({
+			kind: "change",
+			instance: this
+		});
+		const form = byId(this.id);
+		if (!form) return;
+		form.noValidate = true;
+		for (const el of [...form.elements]) {
+			const name = el.name;
+			if (!name || el.type === "submit" || el.type === "button" || el.type === "file") continue;
+			if (el.type === "radio" && !el.checked) continue;
+			this.rec(name).k = true;
+			const value = this.#read(el);
+			const now = get(this.v, name);
+			if (now === void 0 && (value === "" || value === false || Array.isArray(value) && !value.length)) {
+				this.v = set(this.v, name, value);
+				this.b = set(this.b, name, value);
+			} else if (!equal(value, now)) this.set(name, value, true);
+		}
+		if (DEV) for (const rec of this.r.values()) {
+			const control = byId(this.fid(rec.p));
+			if (control && !form.contains(control)) warn("OUTSIDE_FORM", `${rec.p} has a control outside <form {...f.parts.form}>; its events don't reach the form. Move it inside, or call field.set() from its handler.`);
+		}
+	}
+	unmount() {
+		if (!this.mounted) return;
+		this.mounted = false;
+		this.ac?.abort();
+		this.F.c?.stop(this);
+		if (DEV) env.devtools?.({
+			kind: "gone",
+			instance: this
+		});
+	}
+	/** After the framework committed: focus after a failed submit, then announcements (D12). */
+	commit() {
+		if (env.server) return;
+		if (this.fo) {
+			this.fo = false;
+			(byId(`${this.id}-summary`) ?? byId(this.id)?.querySelector("[aria-invalid=\"true\"]") ?? null)?.focus();
+		}
+		if (this.an.length) {
+			liveRegion(this.an.join(" "));
+			this.an = [];
+		}
+	}
+	formParts() {
+		if (this.fp && this.fpv === this.pending) return this.fp;
+		const N = this.N;
+		const h = this.hs ??= {
+			i: (event) => this.#input(event.target),
+			b: (event) => this.blur(event.target),
+			s: (event) => {
+				event.preventDefault();
+				this.submit();
+			},
+			r: (event) => {
+				event.preventDefault();
+				this.reset();
+			},
+			c: (event) => {
+				const link = event.target.closest?.("a[href^='#']");
+				const target = link && byId(decodeURIComponent(link.getAttribute("href").slice(1)));
+				if (!target) return;
+				event.preventDefault();
+				target.focus();
+			}
+		};
+		const pending = this.pending || void 0;
+		const form = {
+			[N.id]: this.id,
+			[N.method]: "post",
+			"data-pending": pending,
+			[N.onSubmit]: h.s,
+			[N.onReset]: h.r,
+			[N.blur]: h.b
+		};
+		for (const key of N.input) form[key] = h.i;
+		for (const spec of Object.values(this.F.f)) if (spec.t === "file") form[N.encType] = "multipart/form-data";
+		this.fpv = this.pending;
+		return this.fp = {
+			form,
+			submit: {
+				[N.type]: "submit",
+				"aria-disabled": pending,
+				"data-pending": pending
+			},
+			summary: {
+				[N.id]: `${this.id}-summary`,
+				[N.tabIndex]: -1,
+				[N.onClick]: h.c
+			}
+		};
+	}
+	/** A field's parts, rebuilt only when what they show moved; each one made when first read. */
+	fieldParts(rec) {
+		if (rec.pc && rec.pv === rec.ver) return rec.pc;
+		rec.oc = void 0;
+		rec.pv = rec.ver;
+		return rec.pc = new Parts(this, rec);
+	}
+	/**
+	* The control's attributes (§5.3): id, name, value, aria wiring and
+	* constraints (D13). The value is the current one, not the baseline, so
+	* a server's `state` renders what was posted.
+	*/
+	control(rec) {
+		const N = this.N;
+		const path = rec.p;
+		const id = this.fid(path);
+		const spec = this.spec(path);
+		const invalid = rec.e !== void 0 || void 0;
+		const control = {
+			[N.id]: id,
+			[N.name]: path
+		};
+		const initial = get(this.v, path);
+		if (spec?.t === "boolean") {
+			control[N.type] = "checkbox";
+			control[N.checked] = initial === true;
+		} else if (spec?.t === "file") {
+			control[N.type] = "file";
+			if (spec.a) control[N.accept] = spec.a;
+			if (spec.m) control[N.multiple] = true;
+		} else control[N.value] = initial == null ? "" : String(initial);
+		control["aria-invalid"] = invalid;
+		control["aria-describedby"] = (invalid ? `${id}-error` : "") + (rec.h ? (invalid ? " " : "") + `${id}-hint` : "") || void 0;
+		if (spec) {
+			if (spec.r && spec.t !== "boolean") control[N.required] = true;
+			if (spec.mn !== void 0) control[N.minLength] = spec.mn;
+			if (spec.mx !== void 0) control[N.maxLength] = spec.mx;
+			if (spec.lo !== void 0) control[N.min] = spec.lo;
+			if (spec.hi !== void 0) control[N.max] = spec.hi;
+		}
+		return control;
+	}
+	/** One radio, or one checkbox of an array field. */
+	optionParts(rec, value) {
+		this.fieldParts(rec);
+		let found = (rec.oc ??= /* @__PURE__ */ new Map()).get(value);
+		if (found) return found;
+		const N = this.N;
+		const initial = get(this.v, rec.p);
+		const array = this.spec(rec.p)?.t === "array" || Array.isArray(initial);
+		const id = `${this.fid(rec.p)}-${String(value)}`;
+		found = {
+			control: {
+				[N.type]: array ? "checkbox" : "radio",
+				[N.name]: rec.p,
+				value: String(value),
+				[N.id]: id,
+				[N.checked]: array ? Array.isArray(initial) && initial.includes(value) : equal(initial, value),
+				"aria-invalid": rec.e !== void 0 || void 0
+			},
+			label: { [N.htmlFor]: id }
+		};
+		rec.oc.set(value, found);
+		return found;
+	}
+	/** The errors shown, in the order the last issues listed them. */
+	errors() {
+		if (this.ec) return this.ec;
+		const shown = [];
+		for (const rec of this.r.values()) if (rec.e !== void 0) shown.push({
+			path: rec.p,
+			message: rec.e,
+			href: `#${this.fid(rec.p)}`
+		});
+		const at = (path) => {
+			const i = this.ord.indexOf(path);
+			return i < 0 ? this.ord.length : i;
+		};
+		return this.ec = shown.sort((a, b) => at(a.path) - at(b.path));
+	}
+};
+/** A field's parts, each built when first read: a render that shows only the control builds only it. */
+var Parts = class {
+	#i;
+	#r;
+	#control;
+	#label;
+	#error;
+	#hint;
+	#group;
+	constructor(instance, rec) {
+		this.#i = instance;
+		this.#r = rec;
+	}
+	get control() {
+		return this.#control ??= this.#i.control(this.#r);
+	}
+	get label() {
+		return this.#label ??= { [this.#i.N.htmlFor]: this.#i.fid(this.#r.p) };
+	}
+	get error() {
+		const { N } = this.#i;
+		const id = `${this.#i.fid(this.#r.p)}-error`;
+		return this.#error ??= N.text ? {
+			[N.id]: id,
+			[N.text]: this.#r.e
+		} : { [N.id]: id };
+	}
+	get hint() {
+		const { N } = this.#i;
+		const id = `${this.#i.fid(this.#r.p)}-hint`;
+		const text = N.text && this.#i.spec(this.#r.p)?.d;
+		return this.#hint ??= text ? {
+			[N.id]: id,
+			[N.text]: text
+		} : { [N.id]: id };
+	}
+	get group() {
+		return this.#group ??= { "aria-describedby": this.#r.e === void 0 ? void 0 : `${this.#i.fid(this.#r.p)}-error` };
+	}
+};
+//#endregion
+export { fail as i, DEV as n, env as r, Instance as t };