@dtkt/protoform 0.0.0-stage → 0.1.0

package/dist/context-DSrebuNf.js

@@ -0,0 +1,1024 @@
+import { FieldElementSchema as e, field as t } from "./gen/dtkt/protoform/v1beta1/protoform_pb.js";
+import { FieldBehavior as n, field_behavior as r } from "./gen/google/api/field_behavior_pb.js";
+import i, { createContext as a, useContext as o } from "react";
+import { ScalarType as s, create as c, createMutableRegistry as l, equals as u, fromJson as d, getOption as f, hasOption as p, isFieldSet as m, merge as ee, toJson as te, toJsonString as ne } from "@bufbuild/protobuf";
+import { createConnectTransport as re } from "@connectrpc/connect-web";
+import { createValidator as ie } from "@bufbuild/protovalidate";
+import { DescriptorProtoSchema as h, EnumDescriptorProtoSchema as ae, FileDescriptorProtoSchema as g, SourceCodeInfo_LocationSchema as oe, file_google_protobuf_any as se, file_google_protobuf_api as ce, file_google_protobuf_compiler_plugin as le, file_google_protobuf_cpp_features as ue, file_google_protobuf_descriptor as de, file_google_protobuf_duration as fe, file_google_protobuf_empty as pe, file_google_protobuf_field_mask as me, file_google_protobuf_go_features as he, file_google_protobuf_java_features as ge, file_google_protobuf_source_context as _e, file_google_protobuf_struct as ve, file_google_protobuf_timestamp as ye, file_google_protobuf_type as be, file_google_protobuf_wrappers as xe } from "@bufbuild/protobuf/wkt";
+import { field as Se } from "@bufbuild/protovalidate/gen/buf/validate/validate_pb.js";
+import { reflect as _ } from "@bufbuild/protobuf/reflect";
+import { base64Decode as Ce, base64Encode as we } from "@bufbuild/protobuf/wire";
+import { Fragment as v, jsx as y, jsxs as b } from "react/jsx-runtime";
+// lib/env.ts
+var x = l(se, ce, ue, de, fe, pe, me, he, ge, _e, ve, ye, be, xe, le), Te = S(x);
+function S(e = x) {
+	return ie({ registry: e });
+}
+function Ee(e = x) {
+	return re({
+		baseUrl: "http://localhost:9900",
+		jsonOptions: { registry: e }
+	});
+}
+var C = class {
+	registry;
+	anyTypeFilter;
+	_transport;
+	_validator;
+	constructor({ registry: e, validator: t, transport: n, anyTypeFilter: r } = {}) {
+		this.registry = e ?? x, this.anyTypeFilter = r ?? (() => !0), this._transport = n, this._validator = t;
+	}
+	get transport() {
+		return this._transport ??= Ee(this.registry), this._transport;
+	}
+	get validator() {
+		return this._validator ??= S(this.registry), this._validator;
+	}
+}, w = i.createContext(new C()), De = () => i.useContext(w);
+// lib/comments.ts
+function Oe(e) {
+	return Ae(ke(e).proto, T(e));
+}
+function ke(e) {
+	switch (e.kind) {
+		case "message":
+		case "enum": return e.file;
+		case "enum_value":
+		case "field":
+		case "oneof": return e.parent.file;
+	}
+}
+function T(e) {
+	switch (e.kind) {
+		case "message": return e.parent ? [
+			...T(e.parent),
+			h.field.nestedType.number,
+			e.parent.proto.nestedType.indexOf(e.proto)
+		] : [g.field.messageType.number, e.file.proto.messageType.indexOf(e.proto)];
+		case "enum": return e.parent ? [
+			...T(e.parent),
+			h.field.enumType.number,
+			e.parent.proto.enumType.indexOf(e.proto)
+		] : [g.field.enumType.number, e.file.proto.enumType.indexOf(e.proto)];
+		case "enum_value": return [
+			...T(e.parent),
+			ae.field.value.number,
+			e.parent.proto.value.indexOf(e.proto)
+		];
+		case "field": return [
+			...T(e.parent),
+			h.field.field.number,
+			e.parent.proto.field.indexOf(e.proto)
+		];
+		case "oneof": return [
+			...T(e.parent),
+			h.field.oneofDecl.number,
+			e.parent.proto.oneofDecl.indexOf(e.proto)
+		];
+	}
+}
+function Ae(e, t) {
+	let n = e.sourceCodeInfo?.location.find((e) => e.path.length === t.length && e.path.every((e, n) => e === t[n]));
+	return n ? {
+		leadingDetached: n.leadingDetachedComments,
+		leading: m(n, oe.field.leadingComments) ? n.leadingComments : void 0,
+		trailing: m(n, oe.field.trailingComments) ? n.trailingComments : void 0
+	} : { leadingDetached: [] };
+}
+// lib/element.ts
+var E = class {
+	proto;
+	valid;
+	hidden;
+	required;
+	documented;
+	constructor(n) {
+		this.proto = n.kind === "field" && p(n, t) ? f(n, t) : c(e), this.required = n.kind === "field" && je(n), this.documented = this.proto.description || k(n), n.kind === "field" ? (this.proto.title = this.proto.title ?? n.jsonName, this.proto.description = this.proto.description ?? Pe(n)) : (this.proto.title = this.proto.title ?? n.localName, this.proto.description = this.proto.description ?? k(n)), this.valid = !!this.proto.type.case, this.hidden = this.proto.hidden ?? !1;
+	}
+	type() {
+		return this.proto.type;
+	}
+	title() {
+		return this.proto.title;
+	}
+	description() {
+		return this.proto.description;
+	}
+}, D = /* @__PURE__ */ new WeakMap();
+function je(e) {
+	return p(e, Se) && f(e, Se).required || p(e, r) && f(e, r).includes(n.REQUIRED);
+}
+function Me(e) {
+	return p(e, r) && f(e, r).includes(n.IDENTIFIER);
+}
+function Ne(e) {
+	return p(e, r) && f(e, r).includes(n.OUTPUT_ONLY);
+}
+function O(e) {
+	let t = D.get(e);
+	return t || (t = new E(e), D.set(e, t)), t;
+}
+function Pe(e) {
+	let t = k(e);
+	if (t) return t;
+	if (e.fieldKind == "map") {
+		let n;
+		n = e.enum ? e.enum.typeName : e.message ? e.message.typeName : A(e.scalar), t = `map<${A(e.mapKey)}, ${n}>`;
+	} else t = e.message ? e.message.typeName : e.enum ? e.enum.typeName : A(e.scalar);
+	return e.fieldKind == "list" && (t = `list<${t}>`), t;
+}
+function k(e, t) {
+	let n = Oe(e), r = n.leadingDetached.map((e) => e.trim());
+	return n.leading && r.push(n.leading.trim()), n.trailing && r.push(n.trailing.trim()), t ? r.join("\n") : r.join(" ");
+}
+function A(e) {
+	switch (e) {
+		case s.DOUBLE: return "double";
+		case s.FLOAT: return "float";
+		case s.INT64: return "int64";
+		case s.UINT64: return "uint64";
+		case s.INT32: return "int32";
+		case s.FIXED64: return "fixed64";
+		case s.FIXED32: return "fixed32";
+		case s.BOOL: return "bool";
+		case s.STRING: return "string";
+		case s.BYTES: return "bytes";
+		case s.UINT32: return "uint32";
+		case s.SFIXED32: return "sfixed32";
+		case s.SFIXED64: return "sfixed64";
+		case s.SINT32: return "sint32";
+		case s.SINT64: return "sint64";
+	}
+}
+// lib/path.ts
+function j(e, t) {
+	return e ? `${e}.${t.name}` : t.name;
+}
+function M(e, t) {
+	return `${e}[${t}]`;
+}
+function N(e, t) {
+	return `${e}[${String(t)}]`;
+}
+function P(e) {
+	let t = "";
+	for (let n of e) switch (n.kind) {
+		case "field":
+		case "oneof":
+			t = j(t, n);
+			break;
+		case "extension": break;
+		case "list_sub":
+			t = M(t, n.index);
+			break;
+		case "map_sub": t = N(t, n.key);
+	}
+	return t;
+}
+// lib/store.ts
+var F = class {
+	revision = 0;
+	dataRevision = 0;
+	listeners = /* @__PURE__ */ new Set();
+	violations = [];
+	byPath = /* @__PURE__ */ new Map();
+	localErrors = /* @__PURE__ */ new Map();
+	submitted = !1;
+	markSubmitted() {
+		this.submitted = !0;
+	}
+	subscribe = (e) => (this.listeners.add(e), () => {
+		this.listeners.delete(e);
+	});
+	snapshot = () => this.revision;
+	dataSnapshot = () => this.dataRevision;
+	dataChanged() {
+		this.dataRevision++, this.revision++, this.emit();
+	}
+	setViolations(e) {
+		this.violations = e, this.byPath = /* @__PURE__ */ new Map();
+		for (let t of e) {
+			let e = P(t.field), n = this.byPath.get(e);
+			n ? n.push(t) : this.byPath.set(e, [t]);
+		}
+		this.revision++, this.emit();
+	}
+	violationsAt(e) {
+		return this.byPath.get(e) ?? [];
+	}
+	setLocalError(e, t) {
+		this.localErrors.get(e) !== t && (t === void 0 ? this.localErrors.delete(e) : this.localErrors.set(e, t), this.revision++, this.emit());
+	}
+	localError(e) {
+		return this.localErrors.get(e);
+	}
+	hasLocalErrors() {
+		return this.localErrors.size > 0;
+	}
+	emit() {
+		for (let e of [...this.listeners]) e();
+	}
+}, I = class {
+	value;
+	path;
+	store;
+	owner;
+	onChange;
+	constructor(e, t, n = {}) {
+		this.value = _(e, c(e, t)), this.owner = n.owner, this.path = n.path ?? "", this.onChange = n.onChange, this.store = n.owner?.store ?? n.store ?? new F();
+	}
+	fields() {
+		return this.value.desc.members.map((e) => e.kind === "oneof" ? new X(this, e) : Y(this, e));
+	}
+	fieldPath(e) {
+		return j(this.path, e);
+	}
+	get errors() {
+		return this.store.violationsAt(this.path);
+	}
+	errorMessages() {
+		return this.errorMessagesAt(this.path);
+	}
+	errorMessagesAt(e) {
+		let t = [], n = this.store.localError(e);
+		n && t.push(n);
+		for (let n of this.store.violationsAt(e)) t.push(n.message);
+		return t;
+	}
+	validate(e) {
+		if (this.owner) return this.owner.validate(e);
+		e ??= Te;
+		let t = e.validate(this.value.desc, this.value.message);
+		return this.store.setViolations(t.kind === "invalid" ? t.violations : []), this.store.setLocalError("", t.kind === "error" ? String(t.error) : void 0), t;
+	}
+	get() {
+		return this.value.message;
+	}
+	set(e) {
+		u(this.value.desc, this.value.message, e) || (this.reset(), ee(this.value.desc, this.value.message, e), this.notify());
+	}
+	clear() {
+		this.reset(), this.notify();
+	}
+	notify() {
+		this.attach(), this.onChange?.(), this.owner ? this.owner.notify() : this.store.dataChanged();
+	}
+	attach() {}
+	reset() {
+		for (let e of this.value.desc.fields) this.value.clear(e);
+	}
+}, L = class extends I {
+	parent;
+	desc;
+	elem;
+	constructor(e, t) {
+		super(t.message, e.value.get(t).message, {
+			owner: e,
+			path: j(e.path, t)
+		}), this.parent = e, this.desc = t, this.elem = O(t);
+	}
+	isSet() {
+		return this.parent.value.isSet(this.desc);
+	}
+	ensure() {
+		this.isSet() || this.notify();
+	}
+	clear() {
+		this.reset(), this.parent.value.clear(this.desc), this.parent.notify();
+	}
+	toString() {
+		return ne(this.value.desc, this.get());
+	}
+	parse(e) {
+		this.set(d(this.value.desc, JSON.parse(e)));
+	}
+	attach() {
+		this.parent.value.isSet(this.desc) || this.parent.value.set(this.desc, this.value);
+	}
+}, R = class {
+	parent;
+	desc;
+	path;
+	elem;
+	constructor(e, t) {
+		this.parent = e, this.desc = t, this.path = j(e.path, t), this.elem = O(t);
+	}
+	get errors() {
+		return this.parent.store.violationsAt(this.path);
+	}
+	errorMessages() {
+		return this.parent.errorMessagesAt(this.path);
+	}
+	changed() {
+		this.parent.notify();
+	}
+}, z = class extends R {
+	get() {
+		return this.parent.value.get(this.desc);
+	}
+	set(e) {
+		this.parent.value.set(this.desc, e), this.changed();
+	}
+	parse(e) {
+		let t = e.trim(), n = this.desc.enum.values.find((e) => e.name === t);
+		if (n) this.set(n.number);
+		else if (/^-?\d+$/.test(t)) this.set(Number(t));
+		else throw Error(`unknown value "${e}" for enum ${this.desc.enum.typeName}`);
+	}
+	toString() {
+		let e = this.get();
+		return this.desc.enum.value[e]?.name ?? String(e);
+	}
+};
+function B(e, t) {
+	for (let n of e.values) if (n.name === t) return n.proto.number;
+}
+function V(e, t, n) {
+	let r = e.value[t]?.name ?? String(t);
+	if (n) {
+		let t = Fe(e);
+		return r.startsWith(t) ? r.slice(t.length) : r;
+	}
+	return r;
+}
+function Fe(e) {
+	return e.name.replace(/([a-z0-9])([A-Z])/g, "$1_$2").toUpperCase() + "_";
+}
+function Ie(e, t) {
+	let n = V(e, t, !0).toLowerCase().replaceAll("_", " ");
+	return n.charAt(0).toUpperCase() + n.slice(1);
+}
+function Le(e) {
+	return e.values.slice(1).map((e) => e.proto.number);
+}
+// lib/scalar.ts
+var H = class extends R {
+	get() {
+		return this.parent.value.get(this.desc);
+	}
+	set(e) {
+		this.parent.value.set(this.desc, e), this.changed();
+	}
+	parse(e) {
+		this.set(K(this.desc.scalar, e));
+	}
+	toString() {
+		return q(this.desc.scalar, this.get());
+	}
+}, Re = 34028234663852886e22, U = {
+	[s.INT32]: [-(2n ** 31n), 2n ** 31n - 1n],
+	[s.SINT32]: [-(2n ** 31n), 2n ** 31n - 1n],
+	[s.SFIXED32]: [-(2n ** 31n), 2n ** 31n - 1n],
+	[s.UINT32]: [0n, 2n ** 32n - 1n],
+	[s.FIXED32]: [0n, 2n ** 32n - 1n],
+	[s.INT64]: [-(2n ** 63n), 2n ** 63n - 1n],
+	[s.SINT64]: [-(2n ** 63n), 2n ** 63n - 1n],
+	[s.SFIXED64]: [-(2n ** 63n), 2n ** 63n - 1n],
+	[s.UINT64]: [0n, 2n ** 64n - 1n],
+	[s.FIXED64]: [0n, 2n ** 64n - 1n]
+}, ze = /^[+-]?(\d+\.?\d*|\.\d+)([eE][+-]?\d+)?$/, Be = /^[+-]?\d+$/;
+function W(e) {
+	return e in U;
+}
+function Ve(e) {
+	return W(e) || e === s.FLOAT || e === s.DOUBLE;
+}
+function G(e, t) {
+	let n = t.trim();
+	switch (e) {
+		case s.STRING: return {
+			ok: !0,
+			value: t
+		};
+		case s.BOOL: {
+			let e = n.toLowerCase();
+			return e === "" || e === "false" || e === "0" ? {
+				ok: !0,
+				value: !1
+			} : e === "true" || e === "1" ? {
+				ok: !0,
+				value: !0
+			} : {
+				ok: !1,
+				error: "Enter true or false"
+			};
+		}
+		case s.BYTES:
+			if (n === "") return {
+				ok: !0,
+				value: /* @__PURE__ */ new Uint8Array()
+			};
+			try {
+				return {
+					ok: !0,
+					value: Ce(n)
+				};
+			} catch {
+				return {
+					ok: !1,
+					error: "Enter valid base64"
+				};
+			}
+		case s.DOUBLE:
+		case s.FLOAT: {
+			if (n === "") return {
+				ok: !0,
+				value: 0
+			};
+			let t = He(n);
+			if (t !== void 0) return {
+				ok: !0,
+				value: t
+			};
+			if (!ze.test(n)) return {
+				ok: !1,
+				error: "Enter a number"
+			};
+			let r = Number(n);
+			return !Number.isFinite(r) || e === s.FLOAT && Math.abs(r) > Re ? {
+				ok: !1,
+				error: "Number is out of range"
+			} : {
+				ok: !0,
+				value: r
+			};
+		}
+		default: {
+			let t = U[e];
+			if (!t) return {
+				ok: !1,
+				error: "Unsupported type"
+			};
+			if (n === "") return {
+				ok: !0,
+				value: J(e) ? 0n : 0
+			};
+			if (!Be.test(n)) return {
+				ok: !1,
+				error: "Enter a whole number"
+			};
+			let r = BigInt(n);
+			return r < t[0] || r > t[1] ? {
+				ok: !1,
+				error: `Value must be between ${t[0]} and ${t[1]}`
+			} : {
+				ok: !0,
+				value: J(e) ? r : Number(r)
+			};
+		}
+	}
+}
+function K(e, t) {
+	let n = G(e, t);
+	if (!n.ok) throw Error(n.error);
+	return n.value;
+}
+function q(e, t) {
+	return e === s.BYTES ? we(t) : String(t);
+}
+function He(e) {
+	switch (e.toLowerCase()) {
+		case "nan": return NaN;
+		case "inf":
+		case "+inf":
+		case "infinity":
+		case "+infinity": return Infinity;
+		case "-inf":
+		case "-infinity": return -Infinity;
+	}
+}
+function J(e) {
+	switch (e) {
+		case s.INT64:
+		case s.UINT64:
+		case s.SINT64:
+		case s.FIXED64:
+		case s.SFIXED64: return !0;
+	}
+	return !1;
+}
+// lib/list.ts
+var Ue = class extends R {
+	get() {
+		return this.parent.value.get(this.desc);
+	}
+	set(e) {
+		this.parent.value.set(this.desc, e), this.changed();
+	}
+	get size() {
+		return this.get().size;
+	}
+	items() {
+		return Array.from(this.get());
+	}
+	messages() {
+		return this.items().map((e, t) => new I(e.desc, e.message, {
+			owner: this.parent,
+			path: M(this.path, t)
+		}));
+	}
+	add(e) {
+		this.get().add(e ?? this.zeroItem()), this.changed();
+	}
+	removeAt(e) {
+		this.replace(this.items().filter((t, n) => n !== e));
+	}
+	move(e, t) {
+		let n = this.items();
+		if (e === t || e < 0 || t < 0 || e >= n.length || t >= n.length) return;
+		let [r] = n.splice(e, 1);
+		n.splice(t, 0, r), this.replace(n);
+	}
+	setAt(e, t) {
+		this.get().set(e, t), this.changed();
+	}
+	clear() {
+		this.get().clear(), this.changed();
+	}
+	toString() {
+		return JSON.stringify(this.items().map((e) => this.itemToJson(e)));
+	}
+	parse(e) {
+		let t = JSON.parse(e);
+		if (!Array.isArray(t)) throw Error(`expected array for list field: ${this.desc.name}`);
+		let n = t.map((e) => this.itemFromJson(e));
+		this.replace(n);
+	}
+	replace(e) {
+		let t = this.get();
+		t.clear();
+		for (let n of e) t.add(n);
+		this.changed();
+	}
+	zeroItem() {
+		switch (this.desc.listKind) {
+			case "message": return _(this.desc.message, c(this.desc.message));
+			case "enum": return this.desc.enum.values[0]?.number ?? 0;
+			case "scalar": return K(this.desc.scalar, "");
+		}
+	}
+	itemToJson(e) {
+		switch (this.desc.listKind) {
+			case "message": return te(this.desc.message, e.message);
+			case "enum": return this.desc.enum.value[e]?.name ?? e;
+			case "scalar": return q(this.desc.scalar, e);
+		}
+	}
+	itemFromJson(e) {
+		switch (this.desc.listKind) {
+			case "message": return _(this.desc.message, d(this.desc.message, e));
+			case "enum": return typeof e == "number" ? e : B(this.desc.enum, String(e)) ?? 0;
+			case "scalar": return K(this.desc.scalar, String(e));
+		}
+	}
+}, We = class extends R {
+	get() {
+		return this.parent.value.get(this.desc);
+	}
+	set(e) {
+		this.parent.value.set(this.desc, e), this.changed();
+	}
+	get size() {
+		return this.get().size;
+	}
+	entries() {
+		return Array.from(this.get().entries());
+	}
+	formatKey(e) {
+		return q(this.desc.mapKey, e);
+	}
+	parseKey(e) {
+		return K(this.desc.mapKey, e);
+	}
+	has(e) {
+		return this.get().has(e);
+	}
+	messages() {
+		return this.entries().map(([e, t]) => [e, new I(t.desc, t.message, {
+			owner: this.parent,
+			path: N(this.path, e)
+		})]);
+	}
+	add(e, t) {
+		return !this.has(e) && (this.get().set(e, t ?? this.zeroValue()), this.changed(), !0);
+	}
+	setValue(e, t) {
+		this.get().set(e, t), this.changed();
+	}
+	delete(e) {
+		this.get().delete(e), this.changed();
+	}
+	rename(e, t) {
+		return e === t || !this.has(t) && (this.replace(this.entries().map(([n, r]) => [n === e ? t : n, r])), !0);
+	}
+	clear() {
+		this.get().clear(), this.changed();
+	}
+	toString() {
+		let e = {};
+		for (let [t, n] of this.entries()) e[this.formatKey(t)] = this.valueToJson(n);
+		return JSON.stringify(e);
+	}
+	parse(e) {
+		let t = JSON.parse(e);
+		if (typeof t != "object" || !t || Array.isArray(t)) throw Error(`expected object for map field: ${this.desc.name}`);
+		this.replace(Object.entries(t).map(([e, t]) => [this.parseKey(e), this.valueFromJson(t)]));
+	}
+	replace(e) {
+		let t = this.get();
+		t.clear();
+		for (let [n, r] of e) t.set(n, r);
+		this.changed();
+	}
+	zeroValue() {
+		switch (this.desc.mapKind) {
+			case "message": return _(this.desc.message, c(this.desc.message));
+			case "enum": return this.desc.enum.values[0]?.number ?? 0;
+			case "scalar": return K(this.desc.scalar, "");
+		}
+	}
+	valueToJson(e) {
+		switch (this.desc.mapKind) {
+			case "message": return te(this.desc.message, e.message);
+			case "enum": return this.desc.enum.value[e]?.name ?? e;
+			case "scalar": return q(this.desc.scalar, e);
+		}
+	}
+	valueFromJson(e) {
+		switch (this.desc.mapKind) {
+			case "message": return _(this.desc.message, d(this.desc.message, e));
+			case "enum": return typeof e == "number" ? e : B(this.desc.enum, String(e)) ?? 0;
+			case "scalar": return K(this.desc.scalar, String(e));
+		}
+	}
+};
+// lib/field.ts
+function Y(e, t) {
+	switch (t.fieldKind) {
+		case "list": return new Ue(e, t);
+		case "map": return new We(e, t);
+		case "message": return new L(e, t);
+		case "scalar": return new H(e, t);
+		case "enum": return new z(e, t);
+	}
+}
+// lib/oneof.ts
+var X = class {
+	parent;
+	oneOf;
+	elem;
+	path;
+	constructor(e, t) {
+		this.parent = e, this.oneOf = t, this.elem = O(t), this.path = j(e.path, t);
+	}
+	get desc() {
+		return this.parent.value.oneofCase(this.oneOf) ?? this.oneOf.fields[0];
+	}
+	get errors() {
+		return [...this.parent.store.violationsAt(this.path), ...this.active()?.errors ?? []];
+	}
+	errorMessages() {
+		return [...this.parent.errorMessagesAt(this.path), ...this.active()?.errorMessages() ?? []];
+	}
+	fields() {
+		return this.oneOf.fields.map((e) => Y(this.parent, e));
+	}
+	active() {
+		let e = this.parent.value.oneofCase(this.oneOf);
+		return e ? Y(this.parent, e) : void 0;
+	}
+	isSet() {
+		return this.parent.value.oneofCase(this.oneOf) !== void 0;
+	}
+	select(e) {
+		let t = this.parent.value.oneofCase(this.oneOf);
+		if (t?.name !== e) {
+			if (t && this.parent.value.clear(t), e !== void 0) {
+				let t = this.oneOf.fields.find((t) => t.name === e);
+				if (!t) throw Error(`field "${e}" is not part of oneof "${this.oneOf.name}"`);
+				this.parent.value.set(t, this.parent.value.get(t));
+			}
+			this.parent.notify();
+		}
+	}
+	clear() {
+		this.select(void 0);
+	}
+	toString() {
+		return this.active()?.toString() ?? "";
+	}
+	parse(e) {
+		this.active()?.parse(e);
+	}
+};
+// lib/kit/bare.tsx
+function Ge({ onSubmit: e, children: t }) {
+	return /* @__PURE__ */ y("form", {
+		"data-pf": "form",
+		noValidate: !0,
+		onSubmit: e,
+		children: t
+	});
+}
+function Ke({ children: e }) {
+	return /* @__PURE__ */ y("div", {
+		"data-pf": "stack",
+		children: e
+	});
+}
+function qe({ id: e, children: t, actions: n, errors: r = [] }) {
+	return /* @__PURE__ */ b(v, { children: [/* @__PURE__ */ b("div", {
+		"data-pf": "row",
+		children: [/* @__PURE__ */ y("div", {
+			"data-pf": "row-content",
+			children: t
+		}), n && /* @__PURE__ */ y("div", {
+			"data-pf": "row-actions",
+			children: n
+		})]
+	}), /* @__PURE__ */ y(Z, {
+		id: `${e}-errors`,
+		errors: r
+	})] });
+}
+function Je({ id: e, label: t, description: n, errors: r, required: i, children: a }) {
+	return /* @__PURE__ */ b("div", {
+		"data-pf": "field",
+		"data-invalid": r.length > 0 || void 0,
+		children: [
+			/* @__PURE__ */ b("label", {
+				"data-pf": "label",
+				id: `${e}-label`,
+				htmlFor: e,
+				children: [t, i && /* @__PURE__ */ y("span", {
+					"aria-hidden": "true",
+					children: " *"
+				})]
+			}),
+			n && /* @__PURE__ */ y("p", {
+				"data-pf": "description",
+				id: `${e}-description`,
+				children: n
+			}),
+			a,
+			/* @__PURE__ */ y(Z, {
+				id: `${e}-errors`,
+				errors: r
+			})
+		]
+	});
+}
+function Ye({ id: e, title: t, description: n, errors: r, depth: i, actions: a, collapsible: o, children: s }) {
+	let c = /* @__PURE__ */ b(v, { children: [/* @__PURE__ */ y("span", {
+		"data-pf": "section-title",
+		id: `${e}-title`,
+		children: t
+	}), a && /* @__PURE__ */ y("span", {
+		"data-pf": "section-actions",
+		children: a
+	})] }), l = /* @__PURE__ */ b(v, { children: [
+		n && /* @__PURE__ */ y("p", {
+			"data-pf": "description",
+			id: `${e}-description`,
+			children: n
+		}),
+		/* @__PURE__ */ y(Z, {
+			id: `${e}-errors`,
+			errors: r
+		}),
+		s
+	] }), u = {
+		"aria-labelledby": `${e}-title`,
+		"aria-describedby": n ? `${e}-description` : void 0
+	};
+	return o ? /* @__PURE__ */ b("details", {
+		"data-pf": "section",
+		"data-depth": i,
+		open: !0,
+		...u,
+		children: [/* @__PURE__ */ y("summary", {
+			"data-pf": "section-summary",
+			children: c
+		}), l]
+	}) : /* @__PURE__ */ b("fieldset", {
+		"data-pf": "section",
+		"data-depth": i,
+		...u,
+		children: [/* @__PURE__ */ y("legend", {
+			"data-pf": "section-legend",
+			children: c
+		}), l]
+	});
+}
+function Z({ id: e, errors: t }) {
+	return t.length === 0 ? null : /* @__PURE__ */ y("ul", {
+		"data-pf": "errors",
+		id: e,
+		"aria-live": "polite",
+		children: t.map((e) => /* @__PURE__ */ y("li", { children: e }, e))
+	});
+}
+function Xe({ value: e, onChange: t, onBlur: n, onEnter: r, type: i = "text", inputMode: a, placeholder: o, mono: s, invalid: c, describedBy: l, ...u }) {
+	return /* @__PURE__ */ y("input", {
+		"data-pf": "input",
+		"data-mono": s || void 0,
+		type: i,
+		inputMode: a,
+		id: u.id,
+		name: u.name,
+		value: e,
+		placeholder: o,
+		disabled: u.disabled,
+		readOnly: u.readOnly,
+		required: u.required,
+		"aria-label": u["aria-label"],
+		"aria-invalid": c || void 0,
+		"aria-describedby": l,
+		onChange: (e) => t(e.target.value),
+		onBlur: n,
+		onKeyDown: r && ((e) => {
+			e.key === "Enter" && (e.preventDefault(), r());
+		})
+	});
+}
+function Ze({ value: e, onChange: t, onBlur: n, rows: r = 4, placeholder: i, mono: a, invalid: o, describedBy: s, ...c }) {
+	return /* @__PURE__ */ y("textarea", {
+		"data-pf": "textarea",
+		"data-mono": a || void 0,
+		id: c.id,
+		name: c.name,
+		rows: r,
+		value: e,
+		placeholder: i,
+		disabled: c.disabled,
+		readOnly: c.readOnly,
+		required: c.required,
+		"aria-label": c["aria-label"],
+		"aria-invalid": o || void 0,
+		"aria-describedby": s,
+		onChange: (e) => t(e.target.value),
+		onBlur: n
+	});
+}
+function Qe({ checked: e, onChange: t, label: n, variant: r = "checkbox", invalid: i, describedBy: a, ...o }) {
+	let s = /* @__PURE__ */ y("input", {
+		"data-pf": "checkbox",
+		type: "checkbox",
+		role: r === "switch" ? "switch" : void 0,
+		id: o.id,
+		name: o.name,
+		checked: e,
+		disabled: o.disabled || o.readOnly,
+		"aria-label": o["aria-label"],
+		"aria-invalid": i || void 0,
+		"aria-describedby": a,
+		onChange: (e) => t(e.target.checked)
+	});
+	return n === void 0 ? s : /* @__PURE__ */ b("label", {
+		"data-pf": "checkbox-label",
+		children: [s, /* @__PURE__ */ y("span", { children: n })]
+	});
+}
+function $e({ value: e, onChange: t, options: n, placeholder: r, invalid: i, describedBy: a, ...o }) {
+	return /* @__PURE__ */ b("select", {
+		"data-pf": "select",
+		id: o.id,
+		name: o.name,
+		value: e,
+		disabled: o.disabled || o.readOnly,
+		required: o.required,
+		"aria-label": o["aria-label"],
+		"aria-invalid": i || void 0,
+		"aria-describedby": a,
+		onChange: (e) => t(e.target.value),
+		children: [r !== void 0 && /* @__PURE__ */ y("option", {
+			value: "",
+			disabled: !0,
+			children: r
+		}), n.map((e) => /* @__PURE__ */ y("option", {
+			value: e.value,
+			disabled: e.disabled,
+			children: e.label
+		}, e.value))]
+	});
+}
+function et({ value: e, onChange: t, options: n, invalid: r, describedBy: i, ...a }) {
+	let o = a.name ?? a.id;
+	return /* @__PURE__ */ y("div", {
+		"data-pf": "radiogroup",
+		role: "radiogroup",
+		id: a.id,
+		"aria-label": a["aria-label"],
+		"aria-labelledby": a.id && !a["aria-label"] ? `${a.id}-label` : void 0,
+		"aria-invalid": r || void 0,
+		"aria-describedby": i,
+		children: n.map((n) => /* @__PURE__ */ b("label", {
+			"data-pf": "radio-label",
+			children: [/* @__PURE__ */ y("input", {
+				"data-pf": "radio",
+				type: "radio",
+				name: o,
+				value: n.value,
+				checked: e === n.value,
+				disabled: a.disabled || a.readOnly || n.disabled,
+				onChange: () => t(n.value)
+			}), /* @__PURE__ */ y("span", { children: n.label })]
+		}, n.value))
+	});
+}
+function tt({ accept: e, fileName: t, onFile: n, invalid: r, describedBy: i, ...a }) {
+	return /* @__PURE__ */ b("div", {
+		"data-pf": "file",
+		children: [/* @__PURE__ */ y("input", {
+			"data-pf": "file-input",
+			type: "file",
+			id: a.id,
+			name: a.name,
+			accept: e?.length ? e.join(",") : void 0,
+			disabled: a.disabled || a.readOnly,
+			"aria-label": a["aria-label"],
+			"aria-invalid": r || void 0,
+			"aria-describedby": i,
+			onChange: (e) => n(e.target.files?.[0])
+		}), t && /* @__PURE__ */ y("span", {
+			"data-pf": "file-name",
+			children: t
+		})]
+	});
+}
+function nt({ variant: e = "secondary", size: t = "md", type: n = "button", disabled: r, onClick: i, children: a, ...o }) {
+	return /* @__PURE__ */ y("button", {
+		"data-pf": "button",
+		"data-variant": e,
+		"data-size": t,
+		type: n,
+		disabled: r,
+		"aria-label": o["aria-label"],
+		onClick: i,
+		children: a
+	});
+}
+var Q = {
+	Form: Ge,
+	Stack: Ke,
+	Row: qe,
+	Field: Je,
+	Section: Ye,
+	TextInput: Xe,
+	TextArea: Ze,
+	Checkbox: Qe,
+	Select: $e,
+	RadioGroup: et,
+	FileInput: tt,
+	Button: nt
+}, rt = {
+	edit: "Edit",
+	clear: "Clear",
+	addItem: "Add item",
+	addEntry: "Add",
+	key: "Key",
+	value: "Value",
+	noItems: "No items",
+	notSet: "Not set",
+	select: "Select…",
+	selectType: "Select type…",
+	selectCase: "None",
+	now: "Now",
+	duplicateKey: "Key already exists",
+	item: (e) => `Item ${e}`,
+	entry: (e) => e,
+	entryKey: (e) => `Key ${e}`,
+	entryValue: (e) => `Value for ${e}`,
+	removeItem: (e) => `Remove item ${e}`,
+	moveItemUp: (e) => `Move item ${e} up`,
+	moveItemDown: (e) => `Move item ${e} down`,
+	removeEntry: (e) => `Remove entry ${e}`
+}, $ = a({
+	kit: Q,
+	renderers: {},
+	messages: rt
+});
+function it() {
+	return o($);
+}
+function at() {
+	return o($).kit;
+}
+function ot() {
+	return o($).messages;
+}
+function st(e, t) {
+	let n = e.resolve?.(t);
+	if (n) return n;
+	let r = [];
+	if (t instanceof X) r.push(`${t.parent.value.desc.typeName}.${t.oneOf.name}`);
+	else {
+		let { desc: e } = t;
+		r.push(`${e.parent.typeName}.${e.name}`), e.message ? r.push(e.message.typeName) : e.enum && r.push(e.enum.typeName);
+	}
+	for (let t of r) if (e.renderers[t]) return e.renderers[t];
+}
+function ct(...e) {
+	return Object.assign({}, Q, ...e);
+}
+export { P as A, Ee as B, B as C, j as D, F as E, A as F, x as H, Me as I, Ne as L, O as M, Pe as N, M as O, k as P, C as R, V as S, L as T, Te as U, S as V, De as W, K as _, at as a, Le as b, Q as c, We as d, Ue as f, Ve as g, W as h, st as i, E as j, N as k, X as l, q as m, rt as n, ot as o, H as p, ct as r, it as s, $ as t, Y as u, G as v, I as w, Ie as x, z as y, w as z };