@dynamicforms/vue-forms 0.17.1 → 0.18.0

package/dist/dynamicforms-vue-forms.js

@@ -1,2890 +1,1965 @@
-import { computed as K, unref as h, isRef as Vt, reactive as Ut, watch as $t, ref as Wt, defineComponent as qt, resolveComponent as lt, openBlock as zt, createBlock as Ht, h as R } from "vue";
-import { isEqual as F, isEmpty as j, isBoolean as Qt, isString as C, truncate as Xt, isArray as yt, isObject as Et } from "lodash-es";
-var I = /* @__PURE__ */ ((n) => (n[n.SUPPRESS = 1] = "SUPPRESS", n[n.HIDDEN = 5] = "HIDDEN", n[n.INVISIBLE = 8] = "INVISIBLE", n[n.FULL = 10] = "FULL", n))(I || {});
-const Kt = 10, ut = new Set(
-  Object.values(I).filter((n) => typeof n == "number")
-), Yt = new Set(
-  Object.values(I).filter((n) => typeof n == "string")
-);
-function z(n) {
-  const t = typeof n == "string" ? `'${n}'` : String(n);
-  return new Error(`${t} is not a DisplayMode constant`);
-}
-((n) => {
-  function t(i) {
-    const r = typeof i == "string" ? i.toUpperCase() : "";
-    if (r === "SUPPRESS") return 1;
-    if (r === "HIDDEN") return 5;
-    if (r === "INVISIBLE") return 8;
-    if (r === "FULL") return 10;
-    throw z(i);
-  }
-  n.fromString = t;
-  function e(i) {
-    if (typeof i == "number") {
-      if (ut.has(i)) return i;
-      throw z(i);
-    }
-    if (typeof i != "string") throw z(i);
-    return n.fromString(i);
-  }
-  n.fromAny = e;
-  function s(i) {
-    return typeof i == "number" ? ut.has(i) : typeof i == "string" ? Yt.has(i.toUpperCase()) : !1;
-  }
-  n.isDefined = s;
-})(I || (I = {}));
-Object.freeze(I);
-const O = I;
-class m {
-  static get classIdentifier() {
-    throw new Error("classIdentifier must be declared");
-  }
-  get classIdentifier() {
-    return this.constructor.classIdentifier;
-  }
-  executorFn;
-  /**
-   * What this action remembers about one of the elements it serves. An action instance is shared - a `List` row
-   * carries the instances the item template carries - so anything an action holds about the element it last ran
-   * over belongs to that element rather than to the action: a verdict, a sequence number, a listener it installed.
-   * The keys are weak, so what an action remembers about a row is released with the row.
-   */
-  states = /* @__PURE__ */ new WeakMap();
-  constructor(t) {
-    this.executorFn = t;
-  }
-  /**
-   * This action's state for `key`, created by `init` the first time it is asked for. The key is the element the
-   * action is running over, or the record that element belongs to where what is remembered is a fact about the
-   * whole record.
-   */
-  state(t, e) {
-    return this.states.has(t) || this.states.set(t, e()), this.states.get(t);
-  }
-  execute(t, e, ...s) {
-    return this.executorFn(t, e, ...s);
-  }
-  get eager() {
-    return !1;
-  }
-  /**
-   * Announces that this action now serves `binding`. It runs once per element the action is registered on, the
-   * copies of that element included: a copy takes on the instances it was copied from and each is told about the
-   * copy as it does.
-   */
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  boundToBinding(t) {
-  }
-  /**
-   * Announces that `binding` no longer holds this action, and takes back what running it left there. It names one
-   * element rather than the action as a whole, because the instance goes on serving every other element it was
-   * registered on. It runs inside the operation that drops the registration, so an operation that unwinds puts the
-   * registration and what this took back both back.
-   */
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  unregisterFrom(t) {
-  }
-}
-class S extends Error {
-}
-const Ct = /* @__PURE__ */ Symbol("ValueChangedAction");
-class P extends m {
-  constructor(t) {
-    super(t);
-  }
-  static get classIdentifier() {
-    return Ct;
-  }
-  execute(t, e, s, i) {
-    return super.execute(t, e, s, i);
-  }
-}
-const k = /* @__PURE__ */ Symbol("Transaction.capture"), St = /* @__PURE__ */ Symbol("Transaction.restore"), xt = /* @__PURE__ */ Symbol("Transaction.announceValue"), At = /* @__PURE__ */ Symbol("Transaction.settleValidity");
-function ct(n) {
-  let t = 0, e = n.parent;
-  for (; e; )
-    t++, e = e.parent;
-  return t;
-}
-class Jt {
-  participants = /* @__PURE__ */ new Map();
-  /** what a rollback has to put back beyond the state slots, newest last */
-  undo = [];
-  /** what the commit has to do once the change stands, in the order it was handed in */
-  settled = [];
-  /** true once the transaction has been unwound, which is what tells a run started inside it to say nothing */
-  unwound = !1;
-  /** the depth the announcement in progress is working at, -1 while none is */
-  passDepth = -1;
-  /** set while a pass is running and an element it has already passed the depth of gets enrolled */
-  restartPass = !1;
-  /** true for a transaction that was rolled back rather than committed */
-  get rolledBack() {
-    return this.unwound;
-  }
-  participant(t) {
-    let e = this.participants.get(t);
-    return e || (e = { element: t, valueDirty: !1, forceValue: !1, validityDirty: !1 }, this.participants.set(t, e)), e;
-  }
-  /**
-   * Records the state of an element the first time the transaction modifies it. The whole of the mutable state
-   * goes into the snapshot rather than the part being written: a rollback that restored some of it would leave
-   * the element in a state the form never held.
-   */
-  touch(t) {
-    const e = this.participant(t);
-    e.snapshot || (e.snapshot = t[k]());
-  }
-  /** Enrols an element as one whose value the commit has to announce. `force` skips the comparison. */
-  markValueChanged(t, e) {
-    const s = this.participant(t);
-    s.valueDirty = !0, e && (s.forceValue = !0), this.noteDepth(t);
-  }
-  /** Enrols an element as one whose verdict the commit has to re-form. */
-  markValidityDirty(t) {
-    this.participant(t).validityDirty = !0, this.noteDepth(t);
-  }
-  /**
-   * Queues an event that states an operation rather than a state. Added and removed items have no net over a
-   * transaction, so they are neither compared nor coalesced: the commit emits them in the order they happened.
-   */
-  recordStructural(t, e) {
-    const s = this.participant(t);
-    (s.structural ??= []).push(e), this.noteDepth(t);
-  }
-  /** True where the commit still owes this element a value announcement. */
-  willAnnounceValue(t) {
-    return this.participants.get(t)?.valueDirty ?? !1;
-  }
-  /**
-   * Registers what a rollback has to put back beyond the element's state slots. The snapshot covers the slots,
-   * which is everything an ordinary write touches; an operation that replaces something else the element carries
-   * hands its own undo in here rather than making every snapshot carry the thing.
-   */
-  whenRolledBack(t) {
-    this.undo.push(t);
-  }
-  /**
-   * Registers work that runs once the transaction has committed, and not at all where it is rolled back. It is
-   * how an operation defers a step that cannot be taken back - cancelling work in flight, for one - until the
-   * change it belongs to actually stands.
-   */
-  whenCommitted(t) {
-    this.settled.push(t);
-  }
-  /**
-   * Notes that an element at or below the depth the pass in progress is working at has been enrolled. The pass
-   * then gives up the rest of its batch and is started again over what is now owed, so the newcomer is reached
-   * before the containers above it: an element a handler writes must still be announced before the container
-   * whose composed value carries that write. The depth is only measured while a pass is running - outside one
-   * there is nothing the answer would change.
-   */
-  noteDepth(t) {
-    this.passDepth < 0 || ct(t) >= this.passDepth && (this.restartPass = !0);
-  }
-  /**
-   * Puts every element the transaction modified back as it found it. Nothing is announced: from an observer's
-   * point of view the transaction never happened. What a rollback cannot take back are side effects - a handler
-   * that called a server during the transaction already did.
-   */
-  rollback() {
-    this.unwound = !0, [...this.participants.values()].reverse().forEach((e) => {
-      e.snapshot && e.element[St](e.snapshot);
-    }), this.participants.clear();
-    for (let e = this.undo.length - 1; e >= 0; e--) this.undo[e]();
-    this.undo.length = 0, this.settled.length = 0;
-  }
-  /**
-   * Announces what the transaction did. Values first and verdicts after, because a container's validators run
-   * with its value announcement and the verdict they reach is what the validity pass then reports. Both passes
-   * run deepest first - field, then row, then list - which is the order the change travelled in.
-   *
-   * A handler may write while the commit runs; its writes join this transaction, so both passes repeat until
-   * nothing is left dirty.
-   */
-  commit() {
-    for (; !(!this.announceValues() && !this.settleValidity()); )
-      ;
-    for (let t = 0; t < this.settled.length; t++) this.settled[t]();
-    this.settled.length = 0;
-  }
-  /**
-   * The dirty participants a pass has to visit, one bucket per nesting depth; ties keep the order they were
-   * enrolled in. A nesting depth is a small integer, so the elements go into buckets rather than through a
-   * comparison sort: a whole-list assignment enrols one participant per field, and ordering those by comparison
-   * would cost more than the announcement it orders.
-   */
-  buckets(t) {
-    const e = [];
-    return this.participants.forEach((s) => {
-      if (!t(s)) return;
-      const i = ct(s.element);
-      (e[i] ??= []).push(s);
-    }), e;
-  }
-  /**
-   * Runs one pass over the dirty participants, deepest bucket first; the caller repeats it until it answers
-   * false. The buckets are taken once, and the pass gives up as soon as a handler enrols an element at or below
-   * the depth being drained: that element is not in the bucket being walked, and going on would reach the
-   * containers above it first. The caller's next pass takes fresh buckets and finds it at its own depth.
-   */
-  pass(t, e) {
-    const s = this.buckets(t);
-    if (!s.length) return !1;
-    for (let i = s.length - 1; i >= 0; i--) {
-      const r = s[i];
-      if (r) {
-        this.passDepth = i, this.restartPass = !1;
-        try {
-          for (let a = 0; a < r.length; a++) {
-            if (this.restartPass) return !0;
-            const o = r[a];
-            t(o) && e(o);
-          }
-        } finally {
-          this.passDepth = -1;
-        }
-        if (this.restartPass) return !0;
-      }
-    }
-    return !0;
-  }
-  announceValues() {
-    return this.pass(
-      (t) => t.valueDirty || t.structural !== void 0,
-      (t) => {
-        const { structural: e } = t, s = t.valueDirty, i = t.forceValue;
-        t.structural = void 0, t.valueDirty = !1, t.forceValue = !1, t.element[xt](this, s, i, e);
-      }
-    );
-  }
-  settleValidity() {
-    return this.pass(
-      (t) => t.validityDirty,
-      (t) => {
-        t.validityDirty = !1, t.element[At](this);
-      }
-    );
-  }
-}
-let A, H;
-function It() {
-  return A;
-}
-class Tt {
-}
-class Zt {
-  open = !0;
-  rollback() {
-    throw this.open ? new Tt() : new TypeError(
-      "this transaction handle is spent: the transaction that handed it out has closed. A handle is only usable inside the call that received it."
-    );
-  }
-  close() {
-    this.open = !1;
-  }
-}
-function ht(n) {
-  if (n != null && typeof n.then == "function")
-    throw new TypeError(
-      "a transaction may not be asynchronous: the callback returned a thenable. Do the awaiting outside and open a transaction for each synchronous part."
-    );
-}
-function J(n) {
-  if (A) {
-    const s = n(H);
-    return ht(s), s;
-  }
-  const t = new Jt(), e = new Zt();
-  A = t, H = e;
-  try {
-    const s = n(e);
-    return ht(s), t.commit(), s;
-  } catch (s) {
-    if (t.rollback(), s instanceof Tt) return;
-    throw s;
-  } finally {
-    A = void 0, H = void 0, e.close();
-  }
-}
-function u(n) {
-  return A ? n(A) : J(() => n(A));
-}
-const Ot = { useMarkdownInValidators: !0 };
-function Gt() {
-  return Ot;
-}
-function te(n) {
-  Object.assign(Ot, n);
-}
-const Ue = {
-  install(n, t) {
-    t && te(t);
-  }
+import { createTranslatable as e, interpolate as t } from "@dynamicforms/translatable";
+import { computed as n, createBlock as r, defineComponent as i, h as a, isRef as o, openBlock as s, reactive as ee, ref as c, resolveComponent as l, toRef as u, unref as d, watch as f } from "vue";
+import { isArray as p, isBoolean as m, isEmpty as h, isEqual as g, isObject as te, isString as _, truncate as ne } from "lodash-es";
+//#region \0rolldown/runtime.js
+var re = Object.defineProperty, ie = (e, t) => {
+	let n = {};
+	for (var r in e) re(n, r, {
+		get: e[r],
+		enumerable: !0
+	});
+	return t || re(n, Symbol.toStringTag, { value: "Module" }), n;
+}, v = /* @__PURE__ */ function(e) {
+	return e[e.SUPPRESS = 1] = "SUPPRESS", e[e.HIDDEN = 5] = "HIDDEN", e[e.INVISIBLE = 8] = "INVISIBLE", e[e.FULL = 10] = "FULL", e;
+}(v || {}), ae = 10, oe = new Set(Object.values(v).filter((e) => typeof e == "number")), se = new Set(Object.values(v).filter((e) => typeof e == "string"));
+function y(e) {
+	let t = typeof e == "string" ? `'${e}'` : String(e);
+	return /* @__PURE__ */ Error(`${t} is not a DisplayMode constant`);
+}
+(function(e) {
+	function t(e) {
+		let t = typeof e == "string" ? e.toUpperCase() : "";
+		if (t === "SUPPRESS") return 1;
+		if (t === "HIDDEN") return 5;
+		if (t === "INVISIBLE") return 8;
+		if (t === "FULL") return 10;
+		throw y(e);
+	}
+	e.fromString = t;
+	function n(e) {
+		if (typeof e == "number") {
+			if (oe.has(e)) return e;
+			throw y(e);
+		}
+		if (typeof e != "string") throw y(e);
+		return v.fromString(e);
+	}
+	e.fromAny = n;
+	function r(e) {
+		return typeof e == "number" ? oe.has(e) : typeof e == "string" && se.has(e.toUpperCase());
+	}
+	e.isDefined = r;
+})(v ||= {}), Object.freeze(v);
+var b = v, x = class {
+	static get classIdentifier() {
+		throw Error("classIdentifier must be declared");
+	}
+	get classIdentifier() {
+		return this.constructor.classIdentifier;
+	}
+	executorFn;
+	states = /* @__PURE__ */ new WeakMap();
+	constructor(e) {
+		this.executorFn = e;
+	}
+	state(e, t) {
+		return this.states.has(e) || this.states.set(e, t()), this.states.get(e);
+	}
+	execute(e, t, ...n) {
+		return this.executorFn(e, t, ...n);
+	}
+	get eager() {
+		return !1;
+	}
+	boundToBinding(e) {}
+	unregisterFrom(e) {}
+}, S = class extends Error {}, ce = Symbol("ValueChangedAction"), C = class extends x {
+	constructor(e) {
+		super(e);
+	}
+	static get classIdentifier() {
+		return ce;
+	}
+	execute(e, t, n, r) {
+		return super.execute(e, t, n, r);
+	}
+}, w = Symbol("Transaction.capture"), le = Symbol("Transaction.restore"), ue = Symbol("Transaction.announceValue"), de = Symbol("Transaction.settleValidity");
+function T(e) {
+	return e;
+}
+function fe(e) {
+	let t = 0, n = e.parent;
+	for (; n;) t++, n = n.parent;
+	return t;
+}
+var pe = class {
+	participants = /* @__PURE__ */ new Map();
+	undo = [];
+	settled = [];
+	unwound = !1;
+	passDepth = -1;
+	restartPass = !1;
+	get rolledBack() {
+		return this.unwound;
+	}
+	participant(e) {
+		let t = this.participants.get(e);
+		return t || (t = {
+			element: e,
+			valueDirty: !1,
+			forceValue: !1,
+			validityDirty: !1
+		}, this.participants.set(e, t)), t;
+	}
+	touch(e) {
+		let t = this.participant(e);
+		t.snapshot ||= T(e)[w]();
+	}
+	markValueChanged(e, t) {
+		let n = this.participant(e);
+		n.valueDirty = !0, t && (n.forceValue = !0), this.noteDepth(e);
+	}
+	markValidityDirty(e) {
+		this.participant(e).validityDirty = !0, this.noteDepth(e);
+	}
+	recordStructural(e, t) {
+		let n = this.participant(e);
+		(n.structural ??= []).push(t), this.noteDepth(e);
+	}
+	willAnnounceValue(e) {
+		return this.participants.get(e)?.valueDirty ?? !1;
+	}
+	whenRolledBack(e) {
+		this.undo.push(e);
+	}
+	whenCommitted(e) {
+		this.settled.push(e);
+	}
+	noteDepth(e) {
+		this.passDepth < 0 || fe(e) >= this.passDepth && (this.restartPass = !0);
+	}
+	rollback() {
+		this.unwound = !0, [...this.participants.values()].reverse().forEach((e) => {
+			e.snapshot && T(e.element)[le](e.snapshot);
+		}), this.participants.clear();
+		for (let e = this.undo.length - 1; e >= 0; e--) this.undo[e]();
+		this.undo.length = 0, this.settled.length = 0;
+	}
+	commit() {
+		for (; !(!this.announceValues() && !this.settleValidity()););
+		for (let e = 0; e < this.settled.length; e++) this.settled[e]();
+		this.settled.length = 0;
+	}
+	buckets(e) {
+		let t = [];
+		return this.participants.forEach((n) => {
+			if (!e(n)) return;
+			let r = fe(n.element);
+			(t[r] ??= []).push(n);
+		}), t;
+	}
+	pass(e, t) {
+		let n = this.buckets(e);
+		if (!n.length) return !1;
+		for (let r = n.length - 1; r >= 0; r--) {
+			let i = n[r];
+			if (i) {
+				this.passDepth = r, this.restartPass = !1;
+				try {
+					for (let n = 0; n < i.length; n++) {
+						if (this.restartPass) return !0;
+						let r = i[n];
+						e(r) && t(r);
+					}
+				} finally {
+					this.passDepth = -1;
+				}
+				if (this.restartPass) return !0;
+			}
+		}
+		return !0;
+	}
+	announceValues() {
+		return this.pass((e) => e.valueDirty || e.structural !== void 0, (e) => {
+			let { structural: t } = e, n = e.valueDirty, r = e.forceValue;
+			e.structural = void 0, e.valueDirty = !1, e.forceValue = !1, T(e.element)[ue](this, n, r, t);
+		});
+	}
+	settleValidity() {
+		return this.pass((e) => e.validityDirty, (e) => {
+			e.validityDirty = !1, T(e.element)[de](this);
+		});
+	}
+}, E, me;
+function he() {
+	return E;
+}
+var ge = class {}, _e = class {
+	open = !0;
+	rollback() {
+		throw this.open ? new ge() : TypeError("this transaction handle is spent: the transaction that handed it out has closed. A handle is only usable inside the call that received it.");
+	}
+	close() {
+		this.open = !1;
+	}
 };
-class N extends String {
-  plugins;
-  options;
-  constructor(t, e, s) {
-    super(t), this.plugins = s, this.options = e;
-  }
-}
-function Z(n) {
-  const t = h(n);
-  return typeof t == "object" && t !== null && "componentName" in t;
-}
-function M(n) {
-  return typeof h(n) == "function";
-}
-class G {
-  /**
-   * Machine-readable identifier of what failed, in kebab-case. Every validator this library ships states one, so
-   * code that reacts to a particular failure does not have to match the message text, which is translated and
-   * configurable. It is optional: an error built by hand carries whatever its author gives it, or nothing.
-   */
-  constructor(t) {
-    this.code = t;
-  }
-  code;
-  /**
-   * True where `other` is an error of this class that renders exactly as this one does and reports the same code.
-   * Two runs of one validator over an unchanged value produce two instances of one message, and this is what lets
-   * the validator hand the field back the instance it already holds rather than a fresh one: an equal error is not
-   * a new error, and nothing re-renders over a verdict that did not move.
-   *
-   * The comparison is over what renders - the component, its bindings, its body and the classes - because that is
-   * what a reader of `field.errors` sees. A structural comparison of the errors themselves answers nothing useful:
-   * `ValidationErrorRenderContent` holds a Vue `computed`, and two of those are never structurally equal.
-   */
-  sameAs(t) {
-    return Object.getPrototypeOf(this) === Object.getPrototypeOf(t) && this.code === t.code && this.componentName === t.componentName && F(this.componentBody, t.componentBody) && F(this.componentBindings, t.componentBindings) && F(this.extraClasses, t.extraClasses);
-  }
-  get componentName() {
-    return "Comment";
-  }
-  get componentBindings() {
-    return {};
-  }
-  get componentBody() {
-    return "";
-  }
-  get extraClasses() {
-    return "";
-  }
-}
-class ee extends G {
-  constructor(t, e = "", s) {
-    super(s), this.text = t, this.classes = e;
-  }
-  text;
-  classes;
-  get componentName() {
-    return "template";
-  }
-  get componentBody() {
-    return this.text;
-  }
-  get extraClasses() {
-    return this.classes;
-  }
-}
-class g extends G {
-  constructor(t, e = "", s) {
-    super(s), this.classes = e, this.text = t, this.textType = K(() => this.getTextType);
-  }
-  classes;
-  text;
-  textType;
-  get resolvedText() {
-    const t = h(this.text);
-    return M(t) ? t() : t;
-  }
-  get getTextType() {
-    const t = this.resolvedText;
-    return t ? t instanceof N ? "md" : Z(t) ? "component" : "string" : "string";
-  }
-  get componentName() {
-    switch (h(this.textType)) {
-      case "string":
-        return "template";
-      case "md":
-        return "vue-markdown";
-      case "component":
-        return this.resolvedText.componentName;
-      default:
-        return "template";
-    }
-  }
-  get componentBindings() {
-    switch (h(this.textType)) {
-      case "string":
-        return {};
-      case "md": {
-        const t = this.resolvedText;
-        return { source: t.toString(), options: t.options, plugins: t.plugins };
-      }
-      case "component":
-        return this.resolvedText.componentProps || {};
-      default:
-        return {};
-    }
-  }
-  get componentBody() {
-    switch (h(this.textType)) {
-      case "string":
-        return this.resolvedText;
-      case "component":
-        return this.resolvedText.componentVHtml || "";
-      default:
-        return "";
-    }
-  }
-  get extraClasses() {
-    return this.classes;
-  }
-}
-class se extends g {
-}
-function b(n) {
-  return Gt().useMarkdownInValidators ? new N(n) : n.replace(/[*_~`]/g, "").replace(/!\[(.*?)\]\(.*?\)/g, "$1").replace(/\[(.*?)\]\((.*?)\)/g, "$1").replace(/#+\s?/g, "").replace(/>\s?/g, "").replace(/(\*|-|\d+\.)\s+/g, "").replace(/`{3}[\s\S]*?`{3}/g, "").replace(/`([^`]+)`/g, "$1").replace(/\n{2,}/g, `
-`);
-}
-const ie = /* @__PURE__ */ Symbol("Validator"), ne = () => b("Validation could not be completed");
-class f extends P {
-  source;
-  /**
-   * Creates a new validator
-   * @param validationFn Function that validates the field value and returns errors or null
-   */
-  constructor(t) {
-    const e = (s, i, r, a) => {
-      const o = this.bindingState(s), l = o.abandon, v = ++o.run, p = s.validationEpoch, it = It();
-      let nt = !1;
-      const $ = () => !nt && o.run === v && s.validationEpoch === p && !it?.rolledBack, rt = new AbortController(), D = () => {
-        $() || (nt = !0, o.abandon === D && (o.abandon = void 0), rt.abort());
-      };
-      l?.();
-      const W = t(r, a, s, rt.signal) || [], q = (E) => J(() => {
-        const L = E?.map((T) => this.claim(T)) ?? [];
-        for (let T = s.errors.length - 1; T >= 0; T--) {
-          const at = s.errors[T];
-          if (at.source === this.source) {
-            const ot = L.findIndex((Mt) => Mt.sameAs(at));
-            ot >= 0 ? L.splice(ot, 1) : s.errors.splice(T, 1);
-          }
-        }
-        L.length > 0 && s.errors.push(...L), s.validate();
-      });
-      return W instanceof Promise ? (o.abandon = D, it?.whenRolledBack(D), s.beginValidating(), W.then(
-        (E) => {
-          $() && q(E);
-        },
-        (E) => {
-          $() && (q([new g(ne(), "", "validation-failed")]), console.error("Validation failed", E));
-        }
-      ).finally(() => {
-        o.abandon === D && (o.abandon = void 0), s.endValidating();
-      }).catch((E) => console.error("Validation failed", E))) : q(W), i(s, r, a);
-    };
-    super(e), this.source = Symbol(this.constructor.name);
-  }
-  /**
-   * Returns the error instance this validator owns and may later withdraw: the argument itself when it carries no
-   * ownership stamp or already carries this validator's, a copy of it when it belongs to another validator. The
-   * stamp is not configurable, so an instance one validator owns can never be reassigned to another; the copy is
-   * what makes an error instance shareable between validators, and it keeps the prototype and every own property,
-   * including the non-enumerable ones, so it renders exactly like the instance it was made from.
-   */
-  claim(t) {
-    const e = t.source;
-    if (e === this.source) return t;
-    const s = { value: this.source, enumerable: !1, configurable: !1 };
-    if (e === void 0)
-      return Object.defineProperty(t, "source", s), t;
-    const i = Object.getOwnPropertyDescriptors(t);
-    return Object.create(Object.getPrototypeOf(t), { ...i, source: s });
-  }
-  static get classIdentifier() {
-    return ie;
-  }
-  get eager() {
-    return !0;
-  }
-  /**
-   * Takes this validator off `field`: the errors it put there are withdrawn and the verdict is re-formed over what
-   * the validators the field still holds have to say. Withdrawing them is what keeps a field from staying invalid
-   * on an error no validator is left to take back.
-   *
-   * A run in flight over the field is cancelled once the removal stands, and not before: a transaction that
-   * unwinds puts the validator and its epoch back, and the run it never cancelled goes on to reach the verdict the
-   * field is then owed. Cancelling it as the removal is made would leave the field reporting itself valid over a
-   * value nothing checked, on the strength of a transaction that never happened.
-   */
-  unregisterFrom(t) {
-    u((e) => {
-      e.whenCommitted(() => this.abandonRun(t));
-      for (let s = t.errors.length - 1; s >= 0; s--)
-        t.errors[s].source === this.source && t.errors.splice(s, 1);
-      t.validate();
-    });
-  }
-  /**
-   * Cancels the asynchronous run in flight over `field`, where there is one. It is called once the field has
-   * stopped holding this validator: the field's validation epoch has moved on by then, so the run's verdict is
-   * already dropped and the signal it handed its check aborts with it.
-   */
-  abandonRun(t) {
-    this.bindingState(t).abandon?.();
-  }
-  /**
-   * What this validator remembers about one of the fields it validates. One instance may be registered on several
-   * fields - every row of a list carries the instances the item template carries - so each field has a record of
-   * its own. A subclass that remembers more widens the record by overriding `newBindingState`.
-   */
-  bindingState(t) {
-    return this.state(t, () => this.newBindingState());
-  }
-  /**
-   * The record a field starts with. `run` is the sequence number of the newest run over that field: every
-   * execution takes the next one and a result is applied only while its number is still the newest, so a slow run
-   * cannot overwrite the verdict of a faster one that started after it.
-   */
-  newBindingState() {
-    return { run: 0 };
-  }
-  replacePlaceholdersFunction(t, e) {
-    return () => {
-      let s = h(t);
-      for (; M(s); )
-        s = h(this.replacePlaceholders(s(), e));
-      return s;
-    };
-  }
-  replacePlaceholders(t, e) {
-    if (M(t)) return this.replacePlaceholdersFunction(t, e);
-    if (Z(t)) return t;
-    if (Vt(t))
-      return this.replacePlaceholdersFunction(() => h(t), e);
-    let s = h(t);
-    return Object.keys(e).forEach((i) => {
-      s = s.replaceAll(`{${i}}`, e[i]);
-    }), t instanceof N ? new N(s.toString(), t.options, t.plugins) : s;
-  }
-}
-class x {
-  /**
-   * Every action registered here, in registration order. It is replaced rather than written when an action is
-   * dropped, so a run already walking it finishes on the array it started with and the removal takes effect from
-   * the next trigger.
-   */
-  actions = [];
-  /**
-   * Registers `action`. It becomes the outermost handler of its identifier, or - where `before` is given and is
-   * registered here under the same identifier - takes that action's place in the order, so `before` wraps it and
-   * reaches it through `supr`. That is what lets an action be added to a chain someone else built and still sit
-   * inside a handler already there.
-   */
-  register(t, e) {
-    if (!(t instanceof m)) throw new Error("Invalid action type");
-    const s = e ? this.actions.indexOf(e) : -1;
-    if (e && (e.classIdentifier !== t.classIdentifier || s < 0))
-      throw new Error("Action to register before is not registered under the same identifier");
-    s < 0 ? this.actions.push(t) : this.actions.splice(s, 0, t);
-  }
-  /** Drops `action` and answers whether it was registered here. */
-  unregister(t) {
-    return this.actions.includes(t) ? (this.actions = this.actions.filter((e) => e !== t), !0) : !1;
-  }
-  /** True where something is registered under `identifier`. */
-  willTrigger(t) {
-    return this.actions.some((e) => e.classIdentifier === t);
-  }
-  /** True where any eager action is registered, whatever identifier it stands under. */
-  get hasEager() {
-    return this.actions.some((t) => t.eager);
-  }
-  /** Runs the actions registered under `ActionClass` and answers with what the outermost of them returned. */
-  trigger(t, e, ...s) {
-    return this.run(t.classIdentifier, !1, e, s);
-  }
-  /**
-   * Runs the eager actions of every identifier, each group on its own. A group is entered at its outermost eager
-   * action, which is the last one registered under that identifier.
-   */
-  triggerEager(t, ...e) {
-    const s = this.actions;
-    for (let i = s.length - 1; i >= 0; i--) {
-      const r = s[i];
-      if (r.eager && x.outermostEager(s, i))
-        try {
-          const a = this.walk(s, i, r.classIdentifier, !0, t, e);
-          x.isPromise(a) && a.then(void 0, (o) => {
-            if (!(o instanceof S)) throw o;
-          });
-        } catch (a) {
-          if (!(a instanceof S)) throw a;
-        }
-    }
-  }
-  /** Runs the eager actions registered under `identifier` and nothing else. */
-  triggerEagerFor(t, e, ...s) {
-    return this.run(t, !0, e, s);
-  }
-  /** the validators registered here, in registration order */
-  get validators() {
-    return this.actions.filter((t) => t instanceof f);
-  }
-  /**
-   * Tells every action here that it serves `owner`. A binding reads the map its declaration holds, so this is what
-   * announces the new element to the actions already in it - the way registering an action announces the elements
-   * it comes to serve.
-   */
-  bindTo(t) {
-    this.actions.forEach((e) => e.boundToBinding(t));
-  }
-  /** True where no eager action of `identifier` stands after `index`, which makes `index` the group's entry. */
-  static outermostEager(t, e) {
-    const s = t[e].classIdentifier;
-    for (let i = t.length - 1; i > e; i--)
-      if (t[i].eager && t[i].classIdentifier === s) return !1;
-    return !0;
-  }
-  /**
-   * True where `value` is a promise, which is what a walk through an asynchronous handler answers with. The test is
-   * the type rather than a `then` member: a handler may answer with a value object that carries one, and calling
-   * `then` on such an object replaces the answer with whatever that call returns.
-   */
-  static isPromise(t) {
-    return t instanceof Promise;
-  }
-  /**
-   * Answers an abort with itself on the asynchronous path as well. Where a handler in the chain is asynchronous, the
-   * walk answers with a promise and the abort raised under it arrives as that promise's rejection; this turns it back
-   * into the value the caller receives, so a promise the trigger answers with resolves to the exception instead of
-   * rejecting with it. Anything else keeps rejecting.
-   */
-  static answerAbort(t) {
-    return x.isPromise(t) ? t.then(void 0, (e) => {
-      if (e instanceof S) return e;
-      throw e;
-    }) : t;
-  }
-  /**
-   * Enters a group at its outermost action. An abort ends the run and is answered with rather than raised: the
-   * exception is what the caller receives - directly where the chain ran synchronously, as what the answered promise
-   * resolves to where it did not - so a run a handler ended is told apart from one that reached no handler and from
-   * one whose handler answered null.
-   */
-  run(t, e, s, i) {
-    const r = this.actions;
-    try {
-      return x.answerAbort(this.walk(r, r.length - 1, t, e, s, i));
-    } catch (a) {
-      if (a instanceof S) return a;
-      throw a;
-    }
-  }
-  /**
-   * Walks from `index` backwards to the first action of `identifier`, handing it a `supr` that continues at the one
-   * before it. The actions registered under other identifiers are passed over, so the array needs no grouping of
-   * its own; the closures exist for the length of the run and only as deep as the run actually goes.
-   */
-  walk(t, e, s, i, r, a) {
-    let o = e;
-    for (; o >= 0 && (t[o].classIdentifier !== s || i && !t[o].eager); ) o--;
-    if (o < 0) return null;
-    const l = (v, ...p) => this.walk(t, o - 1, s, i, v, p);
-    return t[o].execute(r, l, ...a);
-  }
-}
-function V(n) {
-  let t = n;
-  for (; t.fieldName !== void 0 && t.parent; ) t = t.parent;
-  return t;
-}
-function dt(n, t) {
-  let e = n;
-  for (const s of re(t))
-    if (e = e.field?.(s) ?? void 0, !e) return;
-  return e?.declaration === t ? e : void 0;
-}
-function re(n) {
-  const t = [];
-  let e = n;
-  for (; e.fieldName !== void 0 && e.parent; )
-    t.unshift(e.fieldName), e = e.parent;
-  return t;
-}
-function tt(n, t) {
-  const e = dt(t, n);
-  if (e) return e;
-  let s = t.parent;
-  for (; s; ) {
-    const i = dt(V(s), n);
-    if (i) return i;
-    s = s.parent;
-  }
-  return V(n) === V(t.declaration) ? void 0 : n;
-}
-function Pt(n, t) {
-  const e = tt(n, t);
-  if (!e) return [];
-  if (e !== n) return [e];
-  const s = t.bindingsOf(n);
-  return s.length > 0 ? s : [n];
-}
-function ae(n, t) {
-  let e = t.parent;
-  for (; e; ) {
-    const s = e.field?.(n);
-    if (s) return s;
-    e = e.parent;
-  }
-}
-const oe = /* @__PURE__ */ Symbol("ConditionalStatementAction");
-class U extends P {
-  statement;
-  conditionalExecutor;
-  /**
-   * What the elements this action was registered on were declared as. It holds declarations rather than the
-   * elements themselves, so one entry stands for every row of a list, and the element a result is applied to is
-   * the one that declaration names within the record the change happened in.
-   */
-  declarations = /* @__PURE__ */ new Set();
-  /**
-   * The elements this action was registered on. Registration reaches one element at a time - the rows of a list
-   * take the action on one by one, as they are built from the item template that carries it - so this is what
-   * says which of the elements a declaration stands for the action actually drives.
-   */
-  registrations = /* @__PURE__ */ new WeakSet();
-  constructor(t, e) {
-    super((i, r, a, o) => (this.applyIn(V(i)) || i.markRecordIncomplete(), r(i, a, o))), this.statement = t, this.conditionalExecutor = e;
-    const s = new P((i, r, ...a) => (this.applyFrom(i), r(i, ...a)));
-    t.collectFields().forEach((i) => i.registerAction(s));
-  }
-  static get classIdentifier() {
-    return oe;
-  }
-  get eager() {
-    return !0;
-  }
-  boundToBinding(t) {
-    this.declarations.add(t.declaration), this.registrations.add(t);
-  }
-  unregisterFrom(t) {
-    this.registrations.delete(t);
-  }
-  /**
-   * The elements of `scope` this action controls: what each declaration it serves names within that record, and of
-   * those the ones that took the action on. A row of a list that never took it on is not one this action drives.
-   */
-  targetsIn(t) {
-    const e = [];
-    return this.declarations.forEach(
-      (s) => Pt(s, t).forEach((i) => {
-        this.registrations.has(i) && e.push(i);
-      })
-    ), e;
-  }
-  /**
-   * Re-evaluates the statement over one record and applies the result where it changed. The result is recorded
-   * before the executor runs, because an executor that writes a value re-enters through that value's eager pass
-   * and what it has to find there is the result being applied. It answers whether the record held anything for
-   * this action to drive, which is how a caller learns that the record is not assembled yet.
-   */
-  applyIn(t) {
-    const e = this.targetsIn(t);
-    if (e.length === 0) return !1;
-    const s = this.state(t, () => ({ lastResult: void 0 })), i = this.statement.evaluate(t);
-    if (i === s.lastResult) return !0;
-    const r = s.lastResult;
-    return s.lastResult = i, e.forEach((a) => this.conditionalExecutor(a, i, r)), !0;
-  }
-  /**
-   * Re-evaluates the records a change of `source` speaks for. A field of the record the targets live in speaks for
-   * that record alone, which is what keeps one row of a list from answering for another; a field above them - a
-   * form field every row reads - speaks for every record below it, and for the record the action was declared in
-   * where the change reaches none.
-   */
-  applyFrom(t) {
-    const e = /* @__PURE__ */ new Set();
-    this.targetsIn(V(t)).forEach((s) => e.add(V(s))), e.forEach((s) => this.applyIn(s));
-  }
-}
-class le extends U {
-  constructor(t) {
-    super(t, (e, s) => {
-      e.visibility = s ? O.FULL : O.SUPPRESS;
-    });
-  }
-}
-class ue extends U {
-  constructor(t) {
-    super(t, (e, s) => {
-      e.enabled = s;
-    });
-  }
-}
-class ce extends U {
-  constructor(t, e) {
-    super(t, (s, i) => {
-      i && (s.value = e);
-    });
-  }
-}
-var B = /* @__PURE__ */ ((n) => (n[n.NOT = 0] = "NOT", n[n.OR = 1] = "OR", n[n.AND = 2] = "AND", n[n.XOR = 3] = "XOR", n[n.NAND = 4] = "NAND", n[n.NOR = 5] = "NOR", n[n.EQUALS = -1] = "EQUALS", n[n.NOT_EQUALS = -2] = "NOT_EQUALS", n[n.GT = -3] = "GT", n[n.LT = -4] = "LT", n[n.GE = -5] = "GE", n[n.LE = -6] = "LE", n[n.IN = -7] = "IN", n[n.NOT_IN = -8] = "NOT_IN", n[n.INCLUDES = -9] = "INCLUDES", n[n.NOT_INCLUDES = -10] = "NOT_INCLUDES", n))(B || {});
-((n) => {
-  function t(r) {
-    const a = r.toLowerCase();
-    if (a === "not") return 0;
-    if (a === "or") return 1;
-    if (a === "and") return 2;
-    if (a === "xor") return 3;
-    if (a === "nand") return 4;
-    if (a === "nor") return 5;
-    if (a === "equals") return -1;
-    if (["not_equals", "not-equals", "not equals"].includes(a)) return -2;
-    if (a === "gt") return -3;
-    if (a === "lt") return -4;
-    if (a === "ge") return -5;
-    if (a === "le") return -6;
-    if (a === "in") return -7;
-    if (["not_in", "not-in", "not in"].includes(a)) return -8;
-    if (a === "includes") return -9;
-    if (["not_includes", "not-includes", "not includes"].includes(a)) return -10;
-    throw new Error(`Unrecognised operator ${a}`);
-  }
-  n.fromString = t;
-  function e(r) {
-    const a = typeof r == "number" ? r : n.fromString(r);
-    if (Object.values(n).includes(a)) return a;
-    throw new Error(`Unrecognised operator ${r}`);
-  }
-  n.fromAny = e;
-  function s(r) {
-    const a = typeof r == "number" ? r : n.fromString(r);
-    return Object.values(n).includes(a);
-  }
-  n.isDefined = s;
-  function i(r) {
-    return r >= 0;
-  }
-  n.isLogicOperator = i;
-})(B || (B = {}));
-Object.freeze(B);
-const c = B, he = /* @__PURE__ */ Symbol("EnabledChangingAction");
-class kt extends m {
-  constructor(t) {
-    super(t);
-  }
-  static get classIdentifier() {
-    return he;
-  }
-  execute(t, e, s, i) {
-    return super.execute(t, e, s, i);
-  }
-}
-const de = /* @__PURE__ */ Symbol("EnabledChangedAction");
-class Rt extends m {
-  constructor(t) {
-    super(t);
-  }
-  static get classIdentifier() {
-    return de;
-  }
-  execute(t, e, s, i) {
-    return super.execute(t, e, s, i);
-  }
-}
-const ge = /* @__PURE__ */ Symbol("ValidChangedAction");
-class Ft extends m {
-  constructor(t) {
-    super(t);
-  }
-  static get classIdentifier() {
-    return ge;
-  }
-  execute(t, e, s, i) {
-    return super.execute(t, e, s, i);
-  }
-}
-const fe = /* @__PURE__ */ Symbol("VisibilityChangingAction");
-class _t extends m {
-  constructor(t) {
-    super(t);
-  }
-  static get classIdentifier() {
-    return fe;
-  }
-  execute(t, e, s, i) {
-    return super.execute(t, e, s, i);
-  }
-}
-const pe = /* @__PURE__ */ Symbol("VisibilityChangedAction");
-class jt extends m {
-  constructor(t) {
-    super(t);
-  }
-  static get classIdentifier() {
-    return pe;
-  }
-  execute(t, e, s, i) {
-    return super.execute(t, e, s, i);
-  }
-}
-const gt = /* @__PURE__ */ new WeakMap(), ft = /* @__PURE__ */ new WeakMap(), Q = /* @__PURE__ */ new WeakMap(), pt = /* @__PURE__ */ new Set(["validators", "actions"]);
-let X = 0;
-class y {
-  /**
-   * Vue's getTargetType answers INVALID for an object that carries __v_skip, so reactive() hands an element back
-   * unwrapped and no element is ever behind a proxy of its own. isReactive() reads the second flag, and it stays
-   * true because what carries an element's reactivity - its state - is a reactive object.
-   *
-   * Two consequences for a consumer, both silent. watch(field, cb) with a bare element as the source registers
-   * no dependency, because the deep traversal Vue starts for a reactive source stops on __v_skip; the supported
-   * form is watch(() => field.value, cb). And readonly(field) hands the element straight back, so the value it
-   * returns is the element itself and a write through it reaches the field; what a caller hands out instead is
-   * the value, which is frozen, or a computed over it.
-   */
-  get __v_skip() {
-    return !0;
-  }
-  get __v_isReactive() {
-    return !0;
-  }
-  /**
-   * Names the element's class, which is what a structural comparison of two elements answers on. An element keeps
-   * its state in private class fields, so a walk over own keys reaches none of it; lodash reads this tag through
-   * Object.prototype.toString before it compares anything, and a tag it does not know ends the comparison there.
-   * Two elements are therefore equal only where they are the same element. What they hold is compared as
-   * isEqual(a.value, b.value).
-   *
-   * It is an accessor on the prototype, so an element carries nothing for it, and `Object.prototype.toString`
-   * answers `[object Field]` rather than `[object Object]`. Each class states its own name as a literal: a
-   * minifier renames the class itself, so reading the constructor's name would report whatever the build called
-   * it.
-   */
-  get [Symbol.toStringTag]() {
-    return "FormElement";
-  }
-  /**
-   * The element's mutable state, in an object beside the element. `#state` is the tracked view of it: a slot read
-   * through it inside an effect subscribes the effect to that slot, and a write to the slot re-runs the effect.
-   * `#raw` is the same object without the proxy, for the bookkeeping nothing renders from.
-   *
-   * They are private class fields, so no reflection over the element reaches the state or the parent link it
-   * carries, and a subclass reads its own slot type through the accessors below.
-   */
-  #t;
-  #e;
-  constructor(t) {
-    this.#e = t, this.#t = Ut(t);
-  }
-  /** the tracked view of this element's state; a subclass narrows the return type to its own slots */
-  get state() {
-    return this.#t;
-  }
-  /** the untracked view of this element's state; a subclass narrows the return type to its own slots */
-  get raw() {
-    return this.#e;
-  }
-  /**
-   * Exchanges the data this element holds for `data`, in place. The element is the same instance afterwards - its
-   * identity, its actions, its extended properties and its place in whatever container holds it all stand - and it
-   * ends up in the state `bind(data)` would have produced: the values are written, the change history starts over
-   * and the validators run. It is what recycles one element across records, which is what a virtualised renderer
-   * does with the rows it keeps.
-   *
-   * The element makes no statement of its own about the exchange: no `ValueChangedAction` fires for it, the way
-   * none fires for an element that was just built. Its members do announce theirs, and a verdict that moves is
-   * announced as always - a rebound element that is invalid says so to the container holding it. A change an
-   * open transaction is already owed an announcement for stands: the commit reports the pair measured from
-   * where the element was when the transaction opened.
-   *
-   * The data is measured against the element's `declaration`, so a key a record leaves out is taken from the
-   * declaration rather than left as the previous record had it.
-   */
-  rebind(t) {
-    return u((e) => {
-      e.touch(this);
-      const s = e.willAnnounceValue(this), i = this.#e.announcedValue;
-      this.resetTo(this.declaration, t), this.#e.announcedValue = s ? i : this.value;
-    }), this;
-  }
-  /** contains original field value as was provided at creation */
-  get originalValue() {
-    return this.#t.originalValue;
-  }
-  set originalValue(t) {
-    this.touchState(), this.#t.originalValue = t;
-  }
-  /**
-   * The extended properties this element carries: what a consumer attached to it beyond the members the class
-   * declares, such as the label, hint or css class a UI layer binds to the input it renders the element with.
-   * The read is tracked, so a template rendering off `field.extra.label` re-renders when the property is written.
-   *
-   * Every property is optional here, whatever `X` states: a parameter object need not carry one and
-   * setExtendedValues writes as few as a caller likes, so a property `X` declares as required is present only
-   * once something has written it.
-   *
-   * The object is frozen and setExtendedValues is the way to change it: it is the object a transaction captured,
-   * and one written in place would leave a rollback with nothing to put back.
-   */
-  get extra() {
-    return this.#t.extra;
-  }
-  /**
-   * Writes extended properties. The values given are merged over the ones the element carries, so a write of one
-   * property leaves the others standing, and the merged set replaces the object the element held.
-   */
-  setExtendedValues(t) {
-    this.touchState(), this.#t.extra = Object.freeze({ ...this.#e.extra, ...t });
-  }
-  /**
-   * The extended properties a parameter object carries: every key the element does not answer for itself. A key
-   * the element answers for at the time the parameters are applied - `value`, `enabled`, an accessor a subclass
-   * adds - is the element's own; a key that only Object.prototype answers for is nobody's declaration and counts
-   * as extended, and `validators` and `actions` are neither, since they state what to register on the element.
-   *
-   * A member a subclass declares as a class field is not among the keys the element answers for: class fields are
-   * defined on the instance after the base constructor returns, and the parameters are applied inside it. A
-   * subclass that wants a parameter of its own name assigned to it declares that member as an accessor.
-   */
-  extendedOf(t) {
-    const e = /* @__PURE__ */ Object.create(null);
-    return Object.entries(t).forEach(([s, i]) => {
-      pt.has(s) || (!(s in this) || Object.hasOwn(Object.prototype, s)) && (e[s] = i);
-    }), e;
-  }
-  /**
-   * Applies a parameter object: the members the element answers for are assigned to the element and the rest
-   * become its extended properties. Assigning a getter-only member throws a TypeError, which is what a caller
-   * naming `valid` or `parent` past the type system gets.
-   */
-  assignParams(t) {
-    const e = this.extendedOf(t);
-    Object.entries(t).forEach(([s, i]) => {
-      Object.hasOwn(e, s) || pt.has(s) || (this[s] = i);
-    }), j(e) || this.setExtendedValues(e);
-  }
-  /**
-   * Takes this element into the record of the open transaction, where one is open. A write of a single slot that
-   * announces nothing calls it instead of opening a transaction of its own: on its own such a write is already
-   * atomic, and inside a transaction it has to be part of what a rollback puts back.
-   */
-  touchState() {
-    It()?.touch(this);
-  }
-  /**
-   * Records the whole of this element's mutable state, so that a rolled-back transaction can put it back exactly
-   * as it found it. The errors array is copied because a validator writes into the array it is handed rather than
-   * replacing it, and a subclass copies whatever else it holds by reference the same way.
-   *
-   * What is not in the snapshot is the action map, which no write touches: an operation that replaces it hands
-   * the transaction its own undo instead, so this stays the one shape every element captures.
-   */
-  [k]() {
-    return { ...this.#e, errors: [...this.#e.errors] };
-  }
-  /**
-   * Puts a captured state back. It writes through the tracked view, so an effect that ran on the state the
-   * transaction produced runs again on the state it is being returned to, and only for the slots that differ.
-   *
-   * The two validation counters are the slots the element keeps: they count runs that are in flight, and a
-   * rollback cannot un-start one. Put back, the counts would no longer match the endValidating calls still to come.
-   */
-  [St](t) {
-    const e = this.#e.validatingCount, s = this.#e.validatingChildren;
-    Object.assign(this.#t, t), this.#t.validatingCount = e, this.#t.validatingChildren = s;
-  }
-  /**
-   * True while an asynchronous validation is in flight on this element or on anything below it, so a form answers
-   * for the whole tree it holds. The answer is a pair of counters rather than a walk: the element's own runs, and
-   * how many of its children answer the same question with true. A child that starts running while it was idle,
-   * or stops while it was the last one running, moves its container's tally, and a tally that changes the
-   * container's own answer moves the one above it - the transition costs the nesting depth and the read costs
-   * nothing.
-   */
-  get validating() {
-    return this.#t.validatingCount > 0 || this.#t.validatingChildren > 0;
-  }
-  /** announces the start of one asynchronous validation run; validators pair it with endValidating */
-  beginValidating() {
-    const t = !this.validating;
-    this.#t.validatingCount++, t && this.container?.childValidatingChanged(!0);
-  }
-  /** announces the end of one asynchronous validation run */
-  endValidating() {
-    this.#e.validatingCount !== 0 && (this.#t.validatingCount--, this.validating || this.container?.childValidatingChanged(!1));
-  }
-  /**
-   * Records that a child started or stopped answering `validating` with true, and carries the transition further
-   * up where it changes this element's own answer.
-   */
-  childValidatingChanged(t) {
-    const e = this.validating;
-    this.#t.validatingChildren += t ? 1 : -1, this.validating !== e && this.container?.childValidatingChanged(t);
-  }
-  /**
-   * True while an `Action.execute()` at or below this element has yet to settle. An `Action` answers for its own
-   * runs; a container answers for the actions below it; anything else answers false, because an element that is
-   * not an action has nothing to execute.
-   *
-   * It states one thing and `validating` states the other, so a form that gates a submit button on the tree being
-   * idle reads both.
-   */
-  get busy() {
-    return !1;
-  }
-  /**
-   * The composed answer a container gives `busy`, memoised by Vue. An `Action` counts its executions in a counter
-   * of its own, which no container is told about, so the answer is composed over the members instead of tallied;
-   * the computed keeps the walk from repeating while nothing it read has moved, and a member that is itself a
-   * container answers from its own computed.
-   */
-  get busyRead() {
-    let t = ft.get(this);
-    return t || (t = K(() => this.composeBusy()), ft.set(this, t)), t.value;
-  }
-  /** What busyRead computes. A container answers over its members; anything else executes nothing. */
-  composeBusy() {
-    return !1;
-  }
-  /**
-   * Resolves once nothing at or below this element is running - no asynchronous validation, no `Action.execute()`
-   * that has yet to settle. It is what a submit path awaits instead of polling `validating` and `busy`, and it
-   * resolves at once where nothing is running to begin with.
-   *
-   * It answers for the moment it resolves and makes no promise about the one after: work started later leaves the
-   * element running again, so a caller that has to act on a settled tree reads what it needs immediately after
-   * awaiting rather than at its leisure.
-   */
-  settled() {
-    return !this.validating && !this.busy ? Promise.resolve() : new Promise((t) => {
-      const e = $t(
-        () => this.validating || this.busy,
-        (s) => {
-          s || (e(), t());
-        },
-        { flush: "sync" }
-      );
-    });
-  }
-  /**
-   * List of errors. The array handed out is the one the element holds, and a validator writes into it in place,
-   * so a transaction that is open takes the element into its record here: a rollback that put back everything
-   * except the errors would leave a state the form never held.
-   */
-  get errors() {
-    return this.touchState(), this.#t.errors;
-  }
-  set errors(t) {
-    this.touchState(), this.#t.errors = t;
-  }
-  /**
-   * The container that holds this element: the Group it is a member of, or the List whose row it is, and
-   * undefined while no container holds it. The container writes it; everyone else reads it. The read is tracked,
-   * so an effect rendering off the link - `v-if="field.parent"` - re-runs when a container takes the element or
-   * releases it.
-   *
-   * A `List` holds rows and a row is a `Group`, so only a container can be a `List`'s child: `Field` narrows the
-   * type to `Group | undefined`, and the sibling lookup `field.parent?.fields.other` is typed on a field.
-   */
-  get parent() {
-    return this.#t.parent;
-  }
-  /**
-   * The same link at the type the internals reach through. The protected members a container is told things
-   * through - childValidatingChanged, childValidityChanged - are declared here, and a union of two subclasses is
-   * not an instance of this class, which is what a protected access needs.
-   */
-  get container() {
-    return this.#t.parent;
-  }
-  /** when member of a Group, fieldName specifies the name of this field. Written by the group, read-only after */
-  get fieldName() {
-    return this.#t.fieldName;
-  }
-  /**
-   * The element this one was declared as: itself for an element built from parameters, and the element it was
-   * bound from for a binding - transitively, so a binding of a binding names the same one. Every row a `List`
-   * builds from an item template is a binding of it, so a row's member and the template's member it stands for
-   * answer with the same element, and an action registered on the template can tell the two apart.
-   */
-  get declaration() {
-    return this.#e.declaration ?? this;
-  }
-  /** The elements this one holds: a Group's members, a List's rows, none for a leaf. */
-  get members() {
-    return [];
-  }
-  /**
-   * Every element in this element's subtree, this element included, that was declared as `declaration`. It answers
-   * the question a shared action asks when the record it changed in is not the record its targets live in - a form
-   * field that every row of a list reacts to - and it costs the subtree, so it is the path taken only when the
-   * cheaper one, resolving within a single record, does not apply.
-   */
-  bindingsOf(t) {
-    const e = t.declaration, s = [], i = (r) => {
-      r.declaration === e && s.push(r), r.members.forEach(i);
-    };
-    return i(this), s;
-  }
-  /**
-   * States that an eager pass over this element reached an element it needs and did not find it, because the
-   * record this element belongs to was not assembled at the time: a `List` row is built member by member and its
-   * members are bound before any of them holds the row, so a validator comparing two of them runs before the
-   * row exists. The container that finishes the record runs the pass again, and a pass that still reaches
-   * nothing says so again, so the next container above answers for it.
-   */
-  markRecordIncomplete() {
-    this._recordPending || (this._recordPending = !0, X++);
-  }
-  /**
-   * Runs the eager passes outstanding in `element`'s subtree, now that the record it belongs to is assembled. A
-   * container calls it where it has just made a record complete: a Group that has written its members, and a
-   * List that has taken a row, which is what gives the row's fields the form above it.
-   */
-  completeRecords(t = this) {
-    X !== 0 && u(() => {
-      const e = (s) => {
-        s._recordPending && (s._recordPending = !1, X--, s.rerunEagerActions()), s.members.forEach(e);
-      };
-      e(t);
-    });
-  }
-  /** Runs this element's eager actions over the value it holds and re-forms the verdict they reach. */
-  rerunEagerActions() {
-    u((t) => {
-      this.boundActions?.triggerEager(this, this.value, this.value), t.markValidityDirty(this);
-    });
-  }
-  /**
-   * The actions this element answers to, absent where nothing is registered. A binding holds the very map its
-   * declaration holds rather than a copy of it, so the slot is read directly: what a trigger costs is one property
-   * read, and a rule registered on a `List`'s item template reaches every row through the map they share - the
-   * rows built before the registration as much as the ones built after.
-   */
-  get boundActions() {
-    return this._actions;
-  }
-  /** Records that `binding` was made from this element, so a later registration can reach it. */
-  noteBinding(t) {
-    let e = Q.get(this);
-    e || (e = /* @__PURE__ */ new Set(), Q.set(this, e)), e.add(new WeakRef(t));
-  }
-  /**
-   * The bindings made from this element that are still alive, and this element itself. The dead references are
-   * dropped as they are found, which is what keeps the set from growing over the life of a long-lived declaration.
-   */
-  get boundElements() {
-    const t = this.declaration, e = Q.get(t), s = [t];
-    return e && e.forEach((i) => {
-      const r = i.deref();
-      r ? s.push(r) : e.delete(i);
-    }), s;
-  }
-  /**
-   * The map registrations go into: the declaration's, since that is where behaviour lives. The map is made on the
-   * first registration and handed to every binding already made from the declaration, so all of them go on reading
-   * one map through a slot of their own.
-   */
-  get actions() {
-    const t = this.declaration;
-    if (!t._actions) {
-      const e = new x();
-      t.boundElements.forEach((s) => {
-        s._actions = e;
-      });
-    }
-    return t._actions;
-  }
-  /**
-   * Counts the writes that have changed the value of this element or of anything below it. A container reads it
-   * before answering from its value cache, and the read is an ordinary tracked one, so an effect that took a
-   * cached value still re-runs when a descendant is written.
-   */
-  get valueVersion() {
-    return this.#t.valueVersion;
-  }
-  /**
-   * Marks the value of this element and of every ancestor as superseded. It walks the parent chain, so it costs
-   * the nesting depth: an ancestor rebuilds its value the next time one is asked of it, instead of being walked
-   * here for a reader that may never come. The walk also brings each element into the open transaction, so a
-   * rollback puts the versions back and no reader is left holding a cache the tree no longer supports.
-   */
-  bumpValueVersion() {
-    u((t) => {
-      t.touch(this), this.#t.valueVersion++;
-      let e = this.parent;
-      for (; e; )
-        t.touch(e), e.#t.valueVersion++, e = e.parent;
-    });
-  }
-  /**
-   * States that this element's value changed and that every container above it therefore holds a different value
-   * too. Nothing is announced here: the transaction works out at commit which of the elements enrolled actually
-   * ends up holding a different value, and announces those once each.
-   *
-   * `force` states that the caller already knows this element's value changed - one item more or fewer is a
-   * different list whatever the items compare as - so the commit announces it without composing a comparison.
-   */
-  propagateValueChanged(t = !1) {
-    u((e) => {
-      e.markValueChanged(this, t), e.markValidityDirty(this), this.parent?.notifyValueChanged();
-    });
-  }
-  /**
-   * The last step of a construction: it runs inside the transaction the construction is, with the parameters
-   * applied and the value in place, before the element records what it was built as.
-   *
-   * A subclass overrides it to complete what the element was built with. What it writes here is part of the
-   * construction rather than a change of it: the element announces no ValueChangedAction, and what the hook
-   * leaves is what its eager actions and its validators run over, once. An element whose parameters named no
-   * `originalValue` is baselined on the value the hook left and so starts unchanged; one that named a baseline is
-   * measured against it, as any element is. A `Field` writes
-   * `_value`, which reaches the slot on an element built `enabled: false` as well - the value setter, which a
-   * disabled field refuses, states a change, and this is not one.
-   *
-   * A container completes itself through its members, and a member carries a construction of its own: the write
-   * reaches it as any later one would, so the member announces it and reports itself changed. A member that is to
-   * start unchanged is baselined here as well - `this.fields.x.originalValue = this.fields.x.value`.
-   *
-   * `params` is the parameter object the constructor received, where it received one.
-   */
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  constructed(t) {
-  }
-  /**
-   * Re-reads the value that the next ValueChangedAction will report as the one it replaces. A leaf records what
-   * it announced at every announcement, so its copy is always current and there is nothing to re-read; a
-   * container that skipped composing a value nobody was listening for overrides this.
-   */
-  refreshPreviousValue() {
-  }
-  /**
-   * The verdict validate() records and announces: this element's own errors plus the tally of children that
-   * reported themselves invalid, so a container forms it without walking its members. `valid` is the read path
-   * and answers over the live errors arrays instead; the two differ only for an error written into a member
-   * without a validate() call, which is the documented cost of pushing errors by hand.
-   */
-  get countedValid() {
-    return this.#e.errors.length === 0 && this.#e.invalidChildren === 0;
-  }
-  /**
-   * Makes this element the container of `child`: it installs the back-reference, records the name a Group holds
-   * the child under, and takes the child into the invalid tally. An element belongs to one container at a time,
-   * so a child that already carries the link is refused; releaseChild() takes the link away again, and an element
-   * released that way can be handed on. The child's state is unreachable from outside FieldBase, so a container
-   * writes the two slots through here rather than on the child.
-   */
-  takeChild(t, e) {
-    u((s) => {
-      if (t.parent) throw new TypeError("This element already belongs to a container - pass a bind() of it");
-      s.touch(t), t.#t.fieldName = e, t.#t.parent = this, this.adoptChild(t);
-    });
-  }
-  /** Takes a child into this element's invalid tally; a container calls it once the child's parent link exists. */
-  adoptChild(t) {
-    u((e) => {
-      e.touch(this), t.#e.valid || this.#e.invalidChildren++, t.validating && this.childValidatingChanged(!0), e.whenRolledBack(() => {
-        t.validating && this.childValidatingChanged(!1);
-      }), e.markValidityDirty(this);
-    });
-  }
-  /**
-   * Drops a child out of this element's invalid tally and takes its back-reference away. An element keeps no link
-   * to a container that no longer holds it: it would go on moving that container's tally, and the link is what
-   * stands in the way of the element being taken by another container.
-   */
-  releaseChild(t) {
-    u((e) => {
-      e.touch(this), e.touch(t), t.#e.valid || this.#e.invalidChildren--, t.validating && this.childValidatingChanged(!1), e.whenRolledBack(() => {
-        t.validating && this.childValidatingChanged(!0);
-      }), t.#t.parent = void 0, t.#t.fieldName = void 0, e.markValidityDirty(this);
-    });
-  }
-  /**
-   * Brings this element to the state a fresh binding of `source` carrying `value` would be in: `value` is written
-   * where the caller supplied one and `source`'s own value where it did not, the change history - originalValue,
-   * touched - starts over and the errors are dropped and re-established by the validators. A container that reuses
-   * an element at a position it already holds calls it, so the element is indistinguishable from one built for
-   * that position.
-   */
-  resetTo(t, e) {
-    u(() => {
-      const s = e === void 0 ? t.value : e, i = this.errors.length > 0;
-      i && (this.errors = []), this.touched = !1;
-      const r = this.enabled && this.value !== s;
-      this.value = s, this.originalValue = this.value, this.validate(!r && i);
-    });
-  }
-  /** Resets a member. It is what lets a container reach the reset of a child whose class it does not know. */
-  resetChild(t, e, s) {
-    t.resetTo(e, s);
-  }
-  /**
-   * Records a child's new verdict in this element's tally. The child reports it as it settles, and the commit
-   * settles the deepest element first, so the tally a container reads when its own turn comes is finished.
-   */
-  childValidityChanged(t) {
-    this.#e.invalidChildren += t ? -1 : 1;
-  }
-  /**
-   * The composed verdict a container answers `valid` with, memoised by Vue. The walk over the members is what
-   * makes an error pushed into one of them visible without a validate() call, and the computed keeps that walk
-   * from repeating while nothing it read has moved.
-   */
-  get validRead() {
-    let t = gt.get(this);
-    return t || (t = K(() => this.composeValid()), gt.set(this, t)), t.value;
-  }
-  /** What validRead computes. A leaf answers over its own errors; a container adds its members. */
-  composeValid() {
-    return this.#t.errors.length === 0;
-  }
-  // default property handlers
-  get visibility() {
-    return this.#t.visibility;
-  }
-  set visibility(t) {
-    const e = this.#t.visibility;
-    t !== e && u((s) => {
-      const i = this.boundActions?.trigger(_t, this, t, e);
-      if (!(i instanceof S)) {
-        if (!O.isDefined(i ?? t))
-          throw new Error("visibility must be a DisplayMode constant");
-        s.touch(this), this.#t.visibility = O.fromAny(i ?? t), this.boundActions?.trigger(jt, this, this.#t.visibility, e);
-      }
-    });
-  }
-  get enabled() {
-    return this.#t.enabled;
-  }
-  set enabled(t) {
-    const e = this.#t.enabled;
-    t !== e && u((s) => {
-      const i = this.boundActions?.trigger(kt, this, t, e);
-      if (!(i instanceof S)) {
-        if (!Qt(i ?? t)) throw new Error("Enabled value must be boolean");
-        s.touch(this), this.#t.enabled = i ?? t, this.#t.enabled !== e && this.bumpValueVersion(), this.boundActions?.trigger(Rt, this, this.#t.enabled, e);
-      }
-    });
-  }
-  /**
-   * Whether this element and every container above it are enabled. A rendering layer binds one read instead of
-   * walking the parent chain: a disabled `Group` states that its section cannot be edited, and the inputs
-   * rendered from the members inside it read that here.
-   *
-   * It is a read and nothing else. `enabled` on each element stays exactly what was written to it, a write to a
-   * member of a disabled container is accepted the way it always was, and what a container serializes is decided
-   * by the members' own `enabled`. Where a whole subtree is to stop serializing, the members are disabled.
-   *
-   * `enabled` is the only member with a reading of this kind, and it is not a scheme the other members follow.
-   * `visibility` has none because `SUPPRESS` states that an element is absent from the value as well, so folding
-   * it down the tree would decide serialization rather than report it; `value` has none because a container
-   * composes its own from its members rather than passing one down. A rendering layer that needs a third thing
-   * folded down the tree has `provide`/`inject`, which is where the render tree's own context belongs.
-   */
-  get effectiveEnabled() {
-    return this.enabled && (this.parent?.effectiveEnabled ?? !0);
-  }
-  /**
-   * True for an element whose value is composed of its members'. The commit builds such a value only where
-   * something receives it, compares it by content rather than by identity, and runs the element's own validators
-   * with the announcement: a container's validators read the composed value, which exists only once the members
-   * have been written. A leaf's validators have run at the write instead, so its announcement carries no eager
-   * pass of its own.
-   */
-  get composesValue() {
-    return !1;
-  }
-  /**
-   * Whether `child` composes its value from members of its own. It is what lets a container tell a nested
-   * container from a leaf without knowing the classes below it, the way `resetChild` reaches a reset it does not
-   * know the shape of.
-   */
-  childComposesValue(t) {
-    return t.composesValue;
-  }
-  /**
-   * Announces what this element's value became over the transaction. The pair carried is (value now, value at the
-   * last announcement), so a value that went A -> B -> A within the transaction says nothing, and the events an
-   * operation states rather than an element's state - an item added, an item removed - are emitted first, in the
-   * order the operations happened.
-   */
-  [xt](t, e, s, i) {
-    if (i?.forEach((l) => this.boundActions?.trigger(l.actionClass, this, l.item, l.index)), !e) return;
-    const r = this.boundActions;
-    if (this.composesValue && !(r?.willTrigger(Ct) || r?.hasEager)) return;
-    const a = this.value, o = this.#e.announcedValue;
-    !s && (this.composesValue ? F(a, o) : a === o) || (t.touch(this), this.#e.announcedValue = a, this.composesValue && r?.triggerEager(this, a, o), r?.trigger(P, this, a, o));
-  }
-  /**
-   * Forms the verdict this element ends the transaction with and announces a transition of it. The container is
-   * told first, so a handler reads a tally that already includes this verdict, and it is enrolled in the same
-   * transaction: its own verdict is composed of its members', so a member that moves without a value change - an
-   * asynchronous validator, an error pushed in by hand - is what makes the container re-form its own. The
-   * transaction settles the deepest element first, so a container is reached only once its members have decided.
-   */
-  [At](t) {
-    const e = this.#e.valid, s = this.countedValid;
-    if (s === e) return;
-    t.touch(this), this.#e.valid = s;
-    const i = this.container;
-    i && (t.touch(i), i.childValidityChanged(s), t.markValidityDirty(i)), this.boundActions?.trigger(Ft, this, s, e);
-  }
-  validate(t = !1) {
-    u((e) => {
-      t && this.boundActions?.triggerEager(this, this.value, this.value), e.markValidityDirty(this);
-    });
-  }
-  get valid() {
-    return this.#t.errors.length === 0;
-  }
-  get fullValue() {
-    return this.value;
-  }
-  get isChanged() {
-    return !F(this.value, this.originalValue);
-  }
-  /**
-   * Brings a fresh element into the state a binding of `source` is in: it records what it was declared as, takes
-   * on the extended properties and the actions `source` carries, and runs the eager ones over the value it was
-   * built with. The extended properties `overrides` states are written over the ones `source` carries, and they
-   * are in place before the eager pass, so an action reading one sees what the binding ends up carrying. The
-   * actions are the very instances `source` holds - what a binding takes on is data, not behaviour - and each is
-   * told about this element as it is taken on, so an action serving several bindings knows all of them.
-   */
-  boundFrom(t, e, s, i) {
-    this.#e.declaration = t.declaration;
-    const r = { ...t.extra, ...i && this.extendedOf(i) };
-    j(r) || this.setExtendedValues(r);
-    const a = this.declaration;
-    a.noteBinding(this);
-    const o = a._actions;
-    o && (this._actions = o, o.bindTo(this), o.triggerEager(this, e, s));
-  }
-  /**
-   * Registers the actions a constructor received in its parameters: registration without the eager trigger,
-   * because a constructor ends with a single this.actions.triggerEager(...) over the finished value, and an
-   * eager action registered here would otherwise also run once per registration, over a half-built field.
-   */
-  registerInitialActions(t) {
-    t.forEach((e) => {
-      this.actions.register(e), e.boundToBinding(this);
-    });
-  }
-  registerAction(t) {
-    return u((e) => {
-      e.willAnnounceValue(this) || this.refreshPreviousValue(), this.actions.register(t), this.registered(e, t);
-    }), this;
-  }
-  /**
-   * Registers `action` so that `before` wraps it: `before` reaches it through the `supr` it is handed, instead of
-   * ending the run there. It is how an action is added to a chain someone else built and still sits inside a
-   * handler already registered, which registration order alone cannot arrange. `before` has to be registered on
-   * this element under the same identifier.
-   */
-  registerActionBefore(t, e) {
-    return u((s) => {
-      s.willAnnounceValue(this) || this.refreshPreviousValue(), this.actions.register(t, e), this.registered(s, t);
-    }), this;
-  }
-  /**
-   * Drops `action` from this element and answers whether it held it. The instance goes on serving every other
-   * element it was registered on: what is dropped is this element's registration, not the action. A validator
-   * withdraws the errors it put on this element as it goes, so the verdict the element reports is the one the
-   * validators it still holds reach.
-   */
-  unregisterAction(t) {
-    let e = !1;
-    return u((s) => {
-      const i = this.boundActions;
-      if (!i || (e = i.unregister(t), !e)) return;
-      s.touch(this), t instanceof f && this.#t.validationEpoch++;
-      const r = this.boundElements;
-      s.whenRolledBack(() => {
-        i.register(t), r.forEach((a) => t.boundToBinding(a));
-      }), r.forEach((a) => t.unregisterFrom(a));
-    }), e;
-  }
-  /**
-   * Records that `action` is now registered on this element, and that a rollback has to take that back. The
-   * registration is not one of the state slots the snapshot covers, so it hands its own undo in.
-   */
-  registered(t, e) {
-    const s = this.boundElements;
-    s.forEach((i) => {
-      e.boundToBinding(i), e.eager && this.actions.triggerEagerFor(e.classIdentifier, i, i.value, i.originalValue);
-    }), t.whenRolledBack(() => {
-      this.boundActions?.unregister(e) && s.forEach((i) => e.unregisterFrom(i));
-    });
-  }
-  triggerAction(t, ...e) {
-    const s = this.boundActions;
-    return s ? s.trigger(t, this, ...e) : null;
-  }
-  /**
-   * Generation counter of the validators attached to this field. A Validator reads it when a run starts and drops
-   * a result whose epoch no longer matches, so a validation still in flight when clearValidators() is called
-   * cannot push an error onto a field that no longer has the validator that produced it.
-   */
-  get validationEpoch() {
-    return this.#t.validationEpoch;
-  }
-  clearValidators() {
-    u((t) => {
-      t.touch(this), this.#t.validationEpoch++;
-      const e = this.boundActions;
-      if (e) {
-        const s = this.boundElements;
-        e.validators.forEach((i) => {
-          e.unregister(i), t.whenRolledBack(() => {
-            e.register(i), s.forEach((r) => i.boundToBinding(r));
-          }), s.forEach((r) => i.unregisterFrom(r));
-        });
-      }
-      this.errors = [], this.validate();
-    });
-  }
-}
-function me(n, t) {
-  return n ? !t : t;
-}
-class w {
-  operand1;
-  operator;
-  operand2;
-  /**
-   * An operand is a nested `Statement`, a `FieldBase` whose value is compared, or a literal. `undefined` and a
-   * function are neither: they are what a misspelled field name and a field accessor handed over uncalled answer
-   * with, and a statement built from one compares nothing and never fires. The position names which of the two
-   * operands is at fault, so the error points at the place the name was written.
-   */
-  static validateOperand(t, e) {
-    if (t === void 0)
-      throw new TypeError(
-        `Statement operand ${e} is undefined: an operand is a field, a nested statement or a literal, and a name resolving to nothing is none of them. Compare against null to test for an unset value.`
-      );
-    if (typeof t == "function")
-      throw new TypeError(
-        `Statement operand ${e} is a function: an operand is a field, a nested statement or a literal, and a function is none of them. An accessor states the field it answers with: group.field('name').`
-      );
-  }
-  constructor(t, e, s) {
-    w.validateOperand(t, 1), e !== c.NOT && w.validateOperand(s, 2), this.operand1 = t, this.operator = e, this.operand2 = s;
-  }
-  /**
-   * The value an operand contributes. A field operand names a field of the record the statement is evaluated in:
-   * the same statement over a `List` reads row 3's field while row 3 is the record, and a field belonging to no
-   * record of the statement's own - a form field above the list - is read where it stands. A record that does not
-   * hold the field yet contributes undefined, which is what a half-built row answers with.
-   */
-  static valueOf(t, e) {
-    if (t instanceof w) return t.evaluate(e);
-    if (t instanceof y) {
-      const s = e ? tt(t, e) : t;
-      return s ? h(s.value) : void 0;
-    }
-    return t;
-  }
-  get operand1Value() {
-    return w.valueOf(this.operand1);
-  }
-  get operand2Value() {
-    return w.valueOf(this.operand2);
-  }
-  /**
-   * The result of the statement, over the record `scope` belongs to where one is given and over the fields the
-   * statement was built from where it is not.
-   */
-  evaluate(t) {
-    const e = w.valueOf(this.operand1, t), s = w.valueOf(this.operand2, t);
-    switch (this.operator) {
-      // logical operators
-      // `&&` and `||` evaluate to one of their operands, and the operands are of any type. Without the
-      // coercion evaluate() would hand out the operand itself, so `0` or `''` would reach callers that the
-      // signature promises a boolean, and consumers comparing results with !== would see a change where the
-      // logical value stayed the same.
-      case c.AND:
-        return !!(e && s);
-      case c.OR:
-        return !!(e || s);
-      case c.NAND:
-        return !(e && s);
-      case c.NOR:
-        return !(e || s);
-      case c.XOR:
-        return me(!!e, !!s);
-      case c.NOT:
-        return !e;
-      // comparison operators
-      case c.EQUALS:
-        return e == s;
-      case c.NOT_EQUALS:
-        return e != s;
-      case c.LT:
-        return e < s;
-      case c.LE:
-        return e <= s;
-      case c.GE:
-        return e >= s;
-      case c.GT:
-        return e > s;
-      case c.IN:
-        return !!s?.includes?.(e);
-      case c.NOT_IN:
-        return !s?.includes?.(e);
-      case c.INCLUDES:
-        return C(e) && C(s) && e.indexOf(s) >= 0;
-      case c.NOT_INCLUDES:
-        return !(C(e) && C(s) && e.indexOf(s) >= 0);
-      default:
-        throw new Error(`Operator not implemented ${this.operator}`);
-    }
-  }
-  /**
-   * Recursively collects all fields used in this statement and its nested statements
-   * @returns A set of all fields used in this statement
-   */
-  collectFields() {
-    const t = /* @__PURE__ */ new Set();
-    function e(s) {
-      s instanceof y ? t.add(s) : s instanceof w && s.collectFields().forEach((r) => t.add(r));
-    }
-    return e(this.operand1), e(this.operand2), t;
-  }
-}
-const be = /* @__PURE__ */ Symbol("ExecuteAction");
-class Nt extends m {
-  constructor(t) {
-    super(t);
-  }
-  static get classIdentifier() {
-    return be;
-  }
-  execute(t, e, s) {
-    return super.execute(t, e, s);
-  }
-}
-const ve = /* @__PURE__ */ Symbol("ListItemAddedAction");
-class Y extends m {
-  constructor(t) {
-    super(t);
-  }
-  static get classIdentifier() {
-    return ve;
-  }
-  execute(t, e, s, i) {
-    return super.execute(t, e, s, i);
-  }
-}
-const we = /* @__PURE__ */ Symbol("ListItemRemovedAction");
-class Bt extends m {
-  constructor(t) {
-    super(t);
-  }
-  static get classIdentifier() {
-    return we;
-  }
-  execute(t, e, s, i) {
-    return super.execute(t, e, s, i);
-  }
-}
-const Ve = Object.freeze({});
-function Dt() {
-  return {
-    originalValue: void 0,
-    announcedValue: void 0,
-    errors: [],
-    visibility: O.FULL,
-    enabled: !0,
-    valueVersion: 0,
-    validatingCount: 0,
-    validatingChildren: 0,
-    parent: void 0,
-    fieldName: void 0,
-    validationEpoch: 0,
-    declaration: void 0,
-    extra: Ve,
-    valid: !0,
-    invalidChildren: 0
-  };
-}
-function ye() {
-  return { ...Dt(), value: void 0, touched: !1 };
-}
-function Lt() {
-  return {
-    ...Dt(),
-    announcedValue: null,
-    cachedValue: null,
-    cachedValueVersion: -1
-  };
-}
-function Ee() {
-  return { ...Lt(), fieldNames: [] };
-}
-function Ce() {
-  return { ...Lt(), rows: null, rowsVersion: 0, cachedItems: null, cachedItemsVersion: -1 };
-}
-class et extends y {
-  get [Symbol.toStringTag]() {
-    return "Field";
-  }
-  get state() {
-    return super.state;
-  }
-  get raw() {
-    return super.raw;
-  }
-  /** the value slot itself, without the notifications the value setter carries around a write */
-  get _value() {
-    return this.state.value;
-  }
-  set _value(t) {
-    this.state.value = t;
-  }
-  constructor(t) {
-    super(ye()), this.init(t);
-  }
-  /**
-   * Applies the constructor parameters. It is a hook so that a subclass needing different parameter handling
-   * overrides one method instead of redeclaring the constructor - Action does exactly that.
-   *
-   * It is called from this constructor, so it runs before a subclass's own class field initializers, which
-   * only run once super() returns. An override must therefore work off its parameters alone: members the
-   * subclass initializes read as undefined inside it, and anything it writes to such a member is overwritten
-   * the moment the initializer runs.
-   */
-  init(t) {
-    u(() => {
-      if (t) {
-        const { value: e, validators: s, actions: i, ...r } = t;
-        this.registerInitialActions([...s || [], ...i || []]), this.assignParams(r), this._value = e !== void 0 ? e : this.originalValue;
-      }
-      this.constructed(t), this.originalValue === void 0 && (this.originalValue = this._value), this.raw.announcedValue = this._value, this.boundActions?.triggerEager(this, this.value, this.originalValue), this.validate();
-    });
-  }
-  get value() {
-    return this._value;
-  }
-  set value(t) {
-    const e = this._value;
-    !this.enabled || e === t || u((s) => {
-      s.touch(this), this._value = t, this.bumpValueVersion(), this.boundActions?.triggerEager(this, t, e), this.propagateValueChanged();
-    });
-  }
-  /**
-   * The container that holds this field. A `List` holds rows and a row is a `Group`, so a field is never a `List`'s
-   * child and the link is a `Group` wherever there is one: `field.parent?.fields.other` is the sibling lookup, and
-   * it is typed here.
-   */
-  get parent() {
-    return super.parent;
-  }
-  get touched() {
-    return this.state.touched;
-  }
-  set touched(t) {
-    this.touchState(), this.state.touched = t;
-  }
-  bind(t, e) {
-    const s = this.constructor, i = new s({
-      // data is what the caller supplied, and undefined is not supplied; an explicit null is, and clears
-      value: t !== void 0 ? t : this.value,
-      ...e && "originalValue" in e ? { originalValue: e.originalValue } : {},
-      enabled: e?.enabled ?? this.enabled,
-      visibility: e?.visibility ?? this.visibility
-    });
-    return i.boundFrom(this, i.value, i.originalValue, e), i;
-  }
-}
-const mt = /* @__PURE__ */ new WeakMap();
-function bt(n) {
-  if (n != null)
-    return Object.values(n).some((t) => t != null) ? n : void 0;
-}
-class Se extends et {
-  get [Symbol.toStringTag]() {
-    return "Action";
-  }
-  init(t) {
-    u(() => {
-      if (this._value = { label: void 0, icon: void 0 }, t) {
-        const { value: e, originalValue: s, validators: i, actions: r, ...a } = t;
-        this.registerInitialActions([...i || [], ...r || []]), this.assignParams(a);
-        const o = bt(e), l = bt(s);
-        o ? this._value = o : l && (this._value = { ...l }), l && (this.originalValue = Object.freeze({ ...l }));
-      }
-      this.constructed(t), this.originalValue === void 0 && (this.originalValue = this._value), this.raw.announcedValue = this._value, this.boundActions?.triggerEager(this, this.value, this.originalValue), this.validate();
-    });
-  }
-  /**
-   * A copy of the value this action holds, carrying one member rewritten. A member handed undefined is dropped
-   * from the copy rather than written into it: an own key holding undefined is invisible to a reader and to
-   * JSON, but lodash isEqual compares own-key sets, so writing one would leave the action permanently changed
-   * against a baseline that never carried the key.
-   */
-  valueWith(t, e) {
-    const s = { ...this.value };
-    return e === void 0 ? delete s[t] : s[t] = e, s;
-  }
-  get icon() {
-    return this.value.icon;
-  }
-  set icon(t) {
-    this.value.icon !== t && (this.value = this.valueWith("icon", t));
-  }
-  get label() {
-    return this.value.label;
-  }
-  /**
-   * The two setters hand the value setter a new object rather than writing into the one the action holds, so each
-   * is an ordinary value change: the handlers fire, isChanged answers over it, and a disabled action refuses it.
-   * The new object is built only for a member that differs from the one held - the value setter compares by
-   * identity and every copy is a new object, so without the comparison here a write of the value already held
-   * would announce a change and invalidate the value cache of every container above.
-   */
-  set label(t) {
-    this.value.label !== t && (this.value = this.valueWith("label", t));
-  }
-  /** the counter behind `busy`, allocated for this action the first time it is asked for */
-  get busyRuns() {
-    let t = mt.get(this);
-    return t || (t = Wt(0), mt.set(this, t)), t;
-  }
-  /** true from the moment execute() is called until the handler it ran has settled, however it settles */
-  get busy() {
-    return this.busyRuns.value > 0;
-  }
-  /**
-   * Runs the ExecuteAction chain registered on this action and answers what the chain returned. `busy` stands for
-   * the length of the run: the chain is entered synchronously, and the flag is cleared once the value it produced
-   * has settled - a handler that returns a promise holds it for as long as that promise takes, and one that
-   * rejects clears it as it rejects.
-   *
-   * The answer is a promise whatever the handler returns, so a handler that throws rejects it rather than throwing
-   * out of this call: a caller that does not await the answer and does not attach a catch handler leaves that
-   * rejection unhandled. An `AbortEventHandlingException` is the one exception that does not reject: the answer
-   * resolves with it, in a synchronous chain as in an asynchronous one.
-   */
-  async execute(t) {
-    const e = this.busyRuns;
-    e.value++;
-    try {
-      return await this.triggerAction(Nt, t);
-    } finally {
-      e.value--;
-    }
-  }
-}
-const xe = /* @__PURE__ */ qt({
-  __name: "messages-widget",
-  props: {
-    message: {},
-    classes: {}
-  },
-  setup(n) {
-    const t = n, e = lt("vue-markdown"), s = /* @__PURE__ */ new Set([
-      "div",
-      "span",
-      "p",
-      "h1",
-      "h2",
-      "h3",
-      "h4",
-      "h5",
-      "h6",
-      "section",
-      "article",
-      "aside",
-      "nav",
-      "header",
-      "footer",
-      "main",
-      "figure",
-      "figcaption",
-      "blockquote",
-      "pre",
-      "code",
-      "em",
-      "strong",
-      "small",
-      "mark",
-      "del",
-      "ins",
-      "sub",
-      "sup",
-      "i",
-      "b",
-      "u",
-      "s",
-      "a",
-      "img",
-      "button",
-      "input",
-      "textarea",
-      "select",
-      "option",
-      "label",
-      "form",
-      "table",
-      "tr",
-      "td",
-      "th",
-      "thead",
-      "tbody",
-      "tfoot",
-      "ul",
-      "ol",
-      "li",
-      "dl",
-      "dt",
-      "dd"
-    ]), i = () => {
-      if (typeof t.message == "string") return R("span", { class: t.classes }, t.message);
-      const r = [];
-      return t.message.forEach((a) => {
-        switch (a.componentName) {
-          case "template":
-            r.push(R("div", { class: [t.classes, a.extraClasses] }, a.componentBody));
-            break;
-          case "vue-markdown":
-            if (typeof e == "string")
-              console.warn(
-                "You are using markdown for messages-widget, but you haven't registered a vue-markdown component"
-              ), r.push(R("div", { class: [t.classes, a.extraClasses] }, a.componentBindings.source));
-            else {
-              const o = a.componentBindings;
-              r.push(
-                R(e, {
-                  class: [t.classes, a.extraClasses, "df-messages-widget-markdown"],
-                  source: o.source,
-                  options: o.options,
-                  plugins: o.plugins
-                })
-              );
-            }
-            break;
-          default:
-            r.push(
-              R(
-                s.has(a.componentName.toLowerCase()) ? a.componentName : lt(a.componentName),
-                {
-                  class: [t.classes, a.extraClasses],
-                  ...a.componentBindings,
-                  ...a.componentBody ? { innerHTML: a.componentBody } : {}
-                }
-              )
-            );
-            break;
-        }
-      }), r;
-    };
-    return (r, a) => (zt(), Ht(i));
-  }
-}), vt = /* @__PURE__ */ new WeakMap(), Ae = (n) => ({
-  get(t, e, s) {
-    return n(), Reflect.get(t, e, s);
-  },
-  has(t, e) {
-    return n(), Reflect.has(t, e);
-  },
-  ownKeys(t) {
-    return n(), Reflect.ownKeys(t);
-  },
-  getOwnPropertyDescriptor(t, e) {
-    return n(), Reflect.getOwnPropertyDescriptor(t, e);
-  },
-  set(t, e) {
-    throw new TypeError(`fields.${String(e)} cannot be assigned: use addField() to give the group a member`);
-  },
-  defineProperty(t, e) {
-    throw new TypeError(`fields.${String(e)} cannot be redefined: use addField() to give the group a member`);
-  },
-  deleteProperty(t, e) {
-    throw new TypeError(`fields.${String(e)} cannot be deleted: use removeField() to take a member out`);
-  }
+function ve(e) {
+	if (e != null && typeof e.then == "function") throw TypeError("a transaction may not be asynchronous: the callback returned a thenable. Do the awaiting outside and open a transaction for each synchronous part.");
+}
+function D(e) {
+	if (E) {
+		let t = e(me);
+		return ve(t), t;
+	}
+	let t = new pe(), n = new _e();
+	E = t, me = n;
+	try {
+		let r = e(n);
+		return ve(r), t.commit(), r;
+	} catch (e) {
+		if (t.rollback(), e instanceof ge) return;
+		throw e;
+	} finally {
+		E = void 0, me = void 0, n.close();
+	}
+}
+function O(e) {
+	return E ? e(E) : D(() => e(E));
+}
+//#endregion
+//#region src/config.ts
+var ye = { useMarkdownInValidators: !0 };
+function be() {
+	return ye;
+}
+function xe(e) {
+	Object.assign(ye, e);
+}
+var Se = { install(e, t) {
+	t && xe(t);
+} }, k = class extends String {
+	plugins;
+	options;
+	constructor(e, t, n) {
+		super(e), this.plugins = n, this.options = t;
+	}
+};
+function A(e) {
+	let t = d(e);
+	return typeof t == "object" && !!t && "componentName" in t;
+}
+function j(e) {
+	return typeof d(e) == "function";
+}
+var M = class {
+	code;
+	constructor(e) {
+		this.code = e;
+	}
+	sameAs(e) {
+		return Object.getPrototypeOf(this) === Object.getPrototypeOf(e) && this.code === e.code && this.componentName === e.componentName && g(this.componentBody, e.componentBody) && g(this.componentBindings, e.componentBindings) && g(this.extraClasses, e.extraClasses);
+	}
+	get componentName() {
+		return "Comment";
+	}
+	get componentBindings() {
+		return {};
+	}
+	get componentBody() {
+		return "";
+	}
+	get extraClasses() {
+		return "";
+	}
+}, Ce = class extends M {
+	text;
+	classes;
+	constructor(e, t = "", n) {
+		super(n), this.text = e, this.classes = t;
+	}
+	get componentName() {
+		return "template";
+	}
+	get componentBody() {
+		return this.text;
+	}
+	get extraClasses() {
+		return this.classes;
+	}
+}, N = class extends M {
+	classes;
+	text;
+	textType;
+	constructor(e, t = "", r) {
+		super(r), this.classes = t, this.text = e, this.textType = n(() => this.getTextType);
+	}
+	get resolvedText() {
+		let e = d(this.text);
+		return j(e) ? e() : e;
+	}
+	get getTextType() {
+		let e = this.resolvedText;
+		return e ? e instanceof k ? "md" : A(e) ? "component" : "string" : "string";
+	}
+	get componentName() {
+		switch (d(this.textType)) {
+			case "string": return "template";
+			case "md": return "vue-markdown";
+			case "component": return this.resolvedText.componentName;
+			default: return "template";
+		}
+	}
+	get componentBindings() {
+		switch (d(this.textType)) {
+			case "string": return {};
+			case "md": {
+				let e = this.resolvedText;
+				return {
+					source: e.toString(),
+					options: e.options,
+					plugins: e.plugins
+				};
+			}
+			case "component": return this.resolvedText.componentProps || {};
+			default: return {};
+		}
+	}
+	get componentBody() {
+		switch (d(this.textType)) {
+			case "string": return this.resolvedText;
+			case "component": return this.resolvedText.componentVHtml || "";
+			default: return "";
+		}
+	}
+	get extraClasses() {
+		return this.classes;
+	}
+}, we = class extends N {};
+//#endregion
+//#region src/validators/error-message-builder.ts
+function Te(e) {
+	return be().useMarkdownInValidators ? new k(e) : e.replace(/[*_~`]/g, "").replace(/!\[(.*?)\]\(.*?\)/g, "$1").replace(/\[(.*?)\]\((.*?)\)/g, "$1").replace(/#+\s?/g, "").replace(/>\s?/g, "").replace(/(\*|-|\d+\.)\s+/g, "").replace(/`{3}[\s\S]*?`{3}/g, "").replace(/`([^`]+)`/g, "$1").replace(/\n{2,}/g, "\n");
+}
+function P(e) {
+	return o(e) ? n(() => Te(e.value)) : Te(e);
+}
+//#endregion
+//#region src/validators/translations.ts
+var { strings: Ee, translateStrings: De } = e({
+	Required: "Please enter a value",
+	MinValue: "Value must be larger or equal to **{minValue}**",
+	MaxValue: "Value must be less than or equal to **{maxValue}**",
+	ValueInRange: "Value must be between **{minValue}** and **{maxValue}**",
+	MinLength: "Length must be larger or equal to **{minLength}**",
+	MaxLength: "Length must be less than or equal to **{maxLength}**",
+	LengthInRange: "Length must be between **{minLength}** and **{maxLength}**",
+	Pattern: "Value must match pattern \"**{pattern}**\"",
+	InAllowedValues: "Must be one of [**{allowedAsText}**]",
+	ValidationFailed: "Validation could not be completed"
 });
-class d extends y {
-  get [Symbol.toStringTag]() {
-    return "Group";
-  }
-  get state() {
-    return super.state;
-  }
-  get raw() {
-    return super.raw;
-  }
-  _fields;
-  constructor(t, e) {
-    if (super(Ee()), !d.isValidFields(t)) throw new Error("Invalid fields object provided");
-    this._fields = /* @__PURE__ */ Object.create(null), u(() => {
-      if (Object.entries(t).forEach(([i, r]) => this.addField(i, r)), e) {
-        const { value: i, validators: r, actions: a, ...o } = e;
-        this.registerInitialActions([...r || [], ...a || []]), this.assignParams(o), i !== void 0 ? this.assignMembers(i) : this.originalValue !== void 0 && this.assignMembers(this.originalValue);
-      }
-      this.completeRecords(), this.constructed(e);
-      const s = this.value;
-      this.originalValue === void 0 && (this.originalValue = d.baseline(s)), this.raw.announcedValue = s, this.boundActions?.triggerEager(this, s, this.originalValue), this.validate();
-    });
-  }
-  /**
-   * The name array is copied as well: a rollback puts back the set of members the group held, not the array it
-   * went on to hold.
-   */
-  [k]() {
-    const t = super[k]();
-    return t.fieldNames = [...this.raw.fieldNames], t;
-  }
-  /**
-   * The copy of a built value that serves as a baseline. The value getter hands out one object per version, and
-   * a baseline holding that same object would report every value as its own original.
-   */
-  static baseline(t) {
-    return t == null ? t : { ...t };
-  }
-  /**
-   * Takes `field` into this group under `fieldName`. The group ends up holding it exactly as it holds a field the
-   * constructor was given: the field carries the back-reference and the name, its verdict counts towards the
-   * group's, and a rule of the field's that names another member of the form reaches it here.
-   *
-   * The change is announced through the ordinary path, so a group whose value the new field adds to says so once
-   * the transaction closes, and its verdict is re-formed over the members it now holds. The baseline behind
-   * `isChanged` is not rewritten: a group that gains a field holds something its original value does not carry,
-   * and reports itself changed until `originalValue` is written.
-   *
-   * @throws Error where this group already holds a field under `fieldName`.
-   * @throws TypeError where `field` already belongs to a container - pass a `bind()` of it instead.
-   */
-  addField(t, e) {
-    return u((s) => {
-      if (Object.hasOwn(this._fields, t))
-        throw new Error(`Field ${t} is already in this form`);
-      this.takeChild(e, t), s.touch(this), d.setEntry(this._fields, t, e), s.whenRolledBack(() => d.dropEntry(this._fields, t)), this.state.fieldNames.push(t), this.completeRecords(e), this.bumpValueVersion(), this.notifyValueChanged();
-    }), this;
-  }
-  /**
-   * Takes the field held under `fieldName` out of this group and hands it back, answering undefined where the
-   * group holds no field of that name. The field is released whole: the back-reference and the name are gone, its
-   * verdict and its runs in flight no longer count towards the group's, and it is free to be taken by another
-   * container. What it holds - its value, its errors, the change history behind `isChanged` - is its own to report.
-   *
-   * The change is announced through the ordinary path, so the group's value and verdict settle over the members it
-   * has left. The baseline behind `isChanged` is not rewritten, the same way it is not on `addField`.
-   */
-  removeField(t) {
-    let e;
-    return u((s) => {
-      if (!Object.hasOwn(this._fields, t)) return;
-      const i = this._fields[t];
-      s.touch(this), this.releaseChild(i), d.dropEntry(this._fields, t), s.whenRolledBack(() => d.setEntry(this._fields, t, i)), this.state.fieldNames.splice(this.state.fieldNames.indexOf(t), 1), this.bumpValueVersion(), this.notifyValueChanged(), e = i;
-    }), e;
-  }
-  /**
-   * Writes one entry of the member map. The map is typed by the fields interface, which names the members a group
-   * of that type holds and no others, so both here and in dropEntry it is reached as the plain record it is.
-   */
-  static setEntry(t, e, s) {
-    t[e] = s;
-  }
-  /** Drops one entry out of the member map. */
-  static dropEntry(t, e) {
-    delete t[e];
-  }
-  static isValidFields(t) {
-    function e(s) {
-      return s instanceof y;
-    }
-    return typeof t == "object" && t !== null && Object.entries(t).every(([, s]) => e(s));
-  }
-  static createFromFormData(t) {
-    if (t instanceof y)
-      throw new Error("data is already a Form structure, should be a simple object");
-    return new d(
-      t == null ? {} : Object.fromEntries(Object.entries(t).map(([e, s]) => [e, new et({ value: s })]))
-    );
-  }
-  field(t) {
-    return this._fields[t] ?? null;
-  }
-  /**
-   * The typed map of this group's members. What it hands out is a view over the map the group holds: reading it
-   * reaches the members themselves, and every write to it is refused - addField() and removeField() are what
-   * change the set. The view is built the first time something asks for it.
-   *
-   * Reading through it is a tracked read of the set of members, so a template rendering off `group.fields`
-   * re-renders when a field is added or removed; what a member itself holds is tracked by that member.
-   */
-  get fields() {
-    let t = vt.get(this);
-    return t || (t = new Proxy(
-      this._fields,
-      Ae(() => this.state.fieldNames.length)
-    ), vt.set(this, t)), t;
-  }
-  get members() {
-    return this.raw.fieldNames.map((t) => this._fields[t]);
-  }
-  get value() {
-    const t = this.valueVersion;
-    if (this.raw.cachedValueVersion === t) return this.raw.cachedValue;
-    const e = /* @__PURE__ */ Object.create(null);
-    Object.entries(this._fields).forEach(([i, r]) => {
-      const a = r.value;
-      (r.enabled || this.childComposesValue(r) && !j(a)) && (e[i] = a);
-    });
-    const s = j(e) ? null : Object.freeze({ ...e });
-    return this.raw.cachedValue = s, this.raw.cachedValueVersion = t, s;
-  }
-  /**
-   * Writes the members that the given value carries. The members are written one by one and the group says
-   * nothing in between: the transaction the assignment runs in measures the group's own value and its own verdict
-   * once, over the finished set, and announces each at most once.
-   */
-  assignMembers(t) {
-    u(() => {
-      Object.entries(this._fields).forEach(([e, s]) => {
-        (t == null || Object.hasOwn(t, e)) && (s.value = t == null ? null : t[e]);
-      });
-    });
-  }
-  set value(t) {
-    u((e) => {
-      this.assignMembers(t), e.markValidityDirty(this);
-    });
-  }
-  /**
-   * Members are reset one by one rather than assigned as a whole value: the value setter writes only the keys the
-   * value carries, while a member the value leaves out has to end up holding what the template gives it. `source`
-   * supplies that per member, so a group reset from the template it was bound from matches a fresh binding of it.
-   */
-  resetTo(t, e) {
-    const s = t;
-    u((i) => {
-      i.touch(this), this.errors.length && (this.errors = []), Object.entries(this._fields).forEach(([a, o]) => {
-        let l;
-        e === null ? l = null : e !== void 0 && Object.hasOwn(e, a) && (l = e[a]), this.resetChild(o, s.field(a) ?? o, l);
-      });
-      const r = this.value;
-      this.raw.announcedValue = r, this.originalValue = d.baseline(r), super.validate(!0);
-    });
-  }
-  get touched() {
-    return Object.values(this._fields).some((t) => t.touched);
-  }
-  set touched(t) {
-    u(() => {
-      Object.values(this._fields).forEach((e) => {
-        e.touched = t;
-      });
-    });
-  }
-  get fullValue() {
-    const t = /* @__PURE__ */ Object.create(null);
-    return Object.entries(this._fields).forEach(([e, s]) => {
-      t[e] = s.fullValue;
-    }), { ...t };
-  }
-  /**
-   * Records that a member changed its value, so that the transaction in progress works out at commit what this
-   * group's own value became and announces it once. A mutation method calls it itself; you rarely need to.
-   */
-  notifyValueChanged() {
-    this.propagateValueChanged();
-  }
-  get composesValue() {
-    return !0;
-  }
-  /**
-   * A group with nothing listening for its value does not compose one at all, so the copy it holds is from before
-   * the changes nobody received. A registration that adds a listener brings it up to date here, and what the
-   * listener is then told about is the change that follows it.
-   */
-  refreshPreviousValue() {
-    this.raw.announcedValue = this.value;
-  }
-  get valid() {
-    return this.validRead;
-  }
-  composeValid() {
-    return this.state.errors.length === 0 && this.state.fieldNames.every((t) => this._fields[t].valid);
-  }
-  get busy() {
-    return this.busyRead;
-  }
-  composeBusy() {
-    return this.state.fieldNames.some((t) => this._fields[t].busy);
-  }
-  validate(t = !1) {
-    u(() => {
-      t && Object.values(this._fields).forEach((e) => e.validate(!0)), super.validate(t);
-    });
-  }
-  /**
-   * States that `res` was built from the members handed to it. A subclass whose constructor takes something other
-   * than `(fields, params)` - one that composes its own members and passes them to super - never sees them, and
-   * would answer with a binding carrying the declaration's data instead of the record's. That is a difference no
-   * reader would find, so it is refused here rather than returned.
-   */
-  static assertTookFields(t, e, s) {
-    const i = Object.entries(e), r = t.raw.fieldNames;
-    if (!(i.length === r.length && i.every(([a, o]) => t._fields[a] === o)))
-      throw new TypeError(
-        `${s}.bind() built an element that did not take the members it was given, so the binding would carry the declaration's data. A subclass whose constructor does not take (fields, params) has to override bind() and construct itself.`
-      );
-  }
-  bind(t, e) {
-    const s = /* @__PURE__ */ Object.create(null);
-    Object.entries(this._fields).forEach(([a, o]) => {
-      s[a] = o.bind();
-    });
-    const i = this.constructor, r = new i(s, {
-      // data is what the caller supplied, and undefined is not supplied; an explicit null is, and clears
-      value: t !== void 0 ? t : this.value,
-      ...e && "originalValue" in e ? { originalValue: e.originalValue } : {},
-      enabled: e?.enabled ?? this.enabled,
-      visibility: e?.visibility ?? this.visibility
-    });
-    return d.assertTookFields(r, s, this.constructor.name), r.boundFrom(this, r.raw.announcedValue, r.originalValue, e), r;
-  }
-  /**
-   * A record need not name every member: a key it leaves out is taken from the declaration, the same way a member
-   * the constructor is given no value for takes the one it was declared with.
-   */
-  rebind(t) {
-    return super.rebind(t);
-  }
-}
-class _ extends y {
-  get [Symbol.toStringTag]() {
-    return "List";
-  }
-  get state() {
-    return super.state;
-  }
-  get raw() {
-    return super.raw;
-  }
-  _itemTemplate;
-  constructor(t, e) {
-    super(Ce()), this._itemTemplate = t, u(() => {
-      if (e) {
-        const { value: s, validators: i, actions: r, ...a } = e;
-        this.registerInitialActions([...i || [], ...r || []]), this.assignParams(a), s !== void 0 ? this.setValueInternal(s) : this.originalValue !== void 0 && this.setValueInternal(this.originalValue);
-      }
-      this.constructed(e), this.originalValue === void 0 && (this.originalValue = _.baseline(this.value)), this.raw.announcedValue = this.value, this.boundActions?.triggerEager(this, this.value, this.originalValue), this.validate();
-    });
-  }
-  /** The row array is copied as well: a rollback puts back the set the list held, not the array it went on to hold. */
-  [k]() {
-    const t = super[k]();
-    return t.rows = this.raw.rows ? [...this.raw.rows] : this.raw.rows, t;
-  }
-  /**
-   * The copy of a built value that serves as a baseline. The value getter hands out one array per version, and a
-   * baseline holding that same array would report every value as its own original.
-   */
-  static baseline(t) {
-    return t == null ? t : [...t];
-  }
-  processSetValueItem(t) {
-    let e;
-    return t instanceof d ? e = t : this._itemTemplate ? e = this._itemTemplate.bind(t) : e = d.createFromFormData(t), this.takeChild(e), this.completeRecords(e), e;
-  }
-  /**
-   * Builds the item that fills a gap left by an insert beyond the end of the list: the item template bound to its
-   * own values, or an empty group when the list has no template.
-   */
-  createPaddingItem() {
-    return this.processSetValueItem(this._itemTemplate ? this._itemTemplate.bind() : null);
-  }
-  /** Records that the set of rows changed, so `items` rebuilds the frozen array it hands out at the next read. */
-  rowsChanged() {
-    this.state.rowsVersion++;
-  }
-  /** True where `next` is a different set of rows than `previous`: another count, or another row at a position. */
-  static rowsDiffer(t, e) {
-    const s = t ?? [], i = e ?? [];
-    return s.length !== i.length || s.some((r, a) => r !== i[a]);
-  }
-  setValueInternal(t) {
-    if (t != null && !Array.isArray(t))
-      throw new TypeError("Invalid value provided: a list takes an array of rows, or null to empty it");
-    u((e) => {
-      e.touch(this);
-      const s = this.raw.rows;
-      if (t == null)
-        this.releaseRows(), this.state.rows = null;
-      else {
-        const i = this.state.rows ?? [], r = new Array(t.length);
-        for (let a = 0; a < t.length; a++) {
-          const o = t[a], l = i[a];
-          l && this._itemTemplate && !(o instanceof d) ? (this.resetChild(l, this._itemTemplate, o), r[a] = l) : (l && this.releaseChild(l), r[a] = this.processSetValueItem(o));
-        }
-        for (let a = t.length; a < i.length; a++) this.releaseChild(i[a]);
-        this.state.rows = r;
-      }
-      _.rowsDiffer(s, this.raw.rows) && this.rowsChanged(), this.bumpValueVersion();
-    });
-  }
-  get value() {
-    const t = this.valueVersion;
-    if (this.raw.cachedValueVersion === t) return this.raw.cachedValue;
-    const e = this.state.rows?.map((i) => i.value), s = j(e) ? null : Object.freeze(e);
-    return this.raw.cachedValue = s, this.raw.cachedValueVersion = t, s;
-  }
-  set value(t) {
-    u(() => {
-      this.setValueInternal(t), this.propagateValueChanged(!0);
-    });
-  }
-  /**
-   * The rows are taken from `source` where the caller supplied no value of its own, so a list nested in a row that
-   * a whole-list assignment reuses ends up holding what the template gives it rather than what it held before.
-   */
-  resetTo(t, e) {
-    u((s) => {
-      s.touch(this), this.errors.length && (this.errors = []), this.setValueInternal(e === void 0 ? t.value : e);
-      const i = this.value;
-      this.raw.announcedValue = i, this.originalValue = _.baseline(i), super.validate(!0);
-    });
-  }
-  get touched() {
-    return this.state.rows?.some((t) => t.touched) || !1;
-  }
-  set touched(t) {
-    u(() => {
-      this.state.rows?.forEach((e) => {
-        e.touched = t;
-      });
-    });
-  }
-  bind(t, e) {
-    const s = this._itemTemplate?.bind(), i = this.constructor, r = new i(s, {
-      // data is what the caller supplied, and undefined is not supplied; an explicit null is, and clears
-      value: [...(t !== void 0 ? t : this.value) ?? []],
-      ...e && "originalValue" in e ? { originalValue: e.originalValue } : {},
-      enabled: e?.enabled ?? this.enabled,
-      visibility: e?.visibility ?? this.visibility
-    });
-    if (r._itemTemplate !== s)
-      throw new TypeError(
-        `${this.constructor.name}.bind() built a list that did not take the item template it was given, so the binding would carry the declaration's rows. A subclass whose constructor does not take (itemTemplate, params) has to override bind() and construct itself.`
-      );
-    return r.boundFrom(this, r.value, r.originalValue, e), r;
-  }
-  /**
-   * Records that a row changed its value, so that the transaction in progress works out at commit what this
-   * list's own value became and announces it once. The mutation methods call it themselves; you rarely need to.
-   */
-  notifyValueChanged() {
-    this.propagateValueChanged();
-  }
-  get composesValue() {
-    return !0;
-  }
-  /**
-   * A list with nothing listening for its value does not compose one at all, so the copy it holds is from before
-   * the changes nobody received. A registration that adds a listener brings it up to date here, and what the
-   * listener is then told about is the change that follows it.
-   */
-  refreshPreviousValue() {
-    this.raw.announcedValue = this.value;
-  }
-  get valid() {
-    return this.validRead;
-  }
-  composeValid() {
-    return this.state.errors.length === 0 && (this.state.rows?.every((t) => t.valid) ?? !0);
-  }
-  get busy() {
-    return this.busyRead;
-  }
-  composeBusy() {
-    return this.state.rows?.some((t) => t.busy) ?? !1;
-  }
-  validate(t = !1) {
-    u(() => {
-      t && this.state.rows?.forEach((e) => e.validate(!0)), super.validate(t);
-    });
-  }
-  get members() {
-    return this.raw.rows ?? [];
-  }
-  /**
-   * How many rows this list holds. The read is tracked, so a template rendering off it re-renders as rows come and
-   * go.
-   */
-  /**
-   * Every row of this list, each one built from all of its fields. Where `value` states what the list serializes -
-   * rows composed of the fields that are enabled, and null where the list is empty - this states what the list
-   * holds: the disabled fields are in it too, and an empty list reads back as an empty array rather than as null.
-   */
-  get fullValue() {
-    return (this.state.rows ?? []).map((t) => t.fullValue);
-  }
-  get length() {
-    return this.state.rows?.length ?? 0;
-  }
-  /**
-   * The rows this list holds, oldest position first. The array is a frozen copy: it states what the list held at
-   * the read and nothing writes back through it - `push`, `insert`, `remove` and `clear` are what change the set -
-   * so a caller may hold on to it. The rows in it are the live elements, so reading one reports what it holds now.
-   *
-   * The copy is built once per change of the set and handed to every reader until the next one: a write inside a
-   * row changes what the list serializes without changing which rows it holds, and the array a reader took stays
-   * the same one across such a write.
-   */
-  get items() {
-    const t = this.state.rowsVersion;
-    return this.raw.cachedItemsVersion !== t && (this.raw.cachedItems = Object.freeze([...this.raw.rows ?? []]), this.raw.cachedItemsVersion = t), this.raw.cachedItems;
-  }
-  get(t) {
-    return this.state.rows != null ? this.state.rows[t] : void 0;
-  }
-  push(t) {
-    return this.insert(t, this.state.rows?.length ?? 0) + 1;
-  }
-  pop() {
-    return this.remove((this.state.rows?.length ?? 0) - 1);
-  }
-  remove(t) {
-    let e;
-    return u((s) => {
-      if (this.state.rows == null || t < 0 || this.state.rows.length <= t) return;
-      s.touch(this);
-      const i = this.state.rows.splice(t, 1)?.[0];
-      i && (this.releaseChild(i), this.rowsChanged(), this.bumpValueVersion(), e = i, s.recordStructural(this, { actionClass: Bt, item: e, index: t }), this.propagateValueChanged(!0));
-    }), e;
-  }
-  insert(t, e) {
-    let s = 0;
-    return u((i) => {
-      for (i.touch(this), this.state.rows == null && (this.state.rows = []), s = e < 0 ? Math.max(this.state.rows.length + e, 0) : e; this.state.rows.length < s; ) {
-        const a = this.createPaddingItem(), o = this.state.rows.push(a) - 1;
-        this.bumpValueVersion(), i.recordStructural(this, { actionClass: Y, item: a, index: o });
-      }
-      const r = this.processSetValueItem(t);
-      this.state.rows.splice(s, 0, r), i.recordStructural(this, { actionClass: Y, item: r, index: s }), this.rowsChanged(), this.bumpValueVersion(), this.propagateValueChanged(!0);
-    }), s;
-  }
-  /** Drops every row this list holds out of its tally, so a row that changes its verdict later is not counted. */
-  releaseRows() {
-    this.state.rows?.forEach((t) => this.releaseChild(t));
-  }
-  clear() {
-    u((t) => {
-      const e = (this.state.rows?.length ?? 0) > 0;
-      t.touch(this), this.releaseRows(), this.state.rows = null, e && this.rowsChanged(), this.bumpValueVersion(), this.propagateValueChanged(e);
-    });
-  }
-}
-class Ie extends f {
-  constructor(t, e, s) {
-    const i = (r, a, o) => {
-      this.comparisonState(o).oldValue = a;
-      const l = this.resolve(o);
-      return l ? (this.listenOn(l), this.isValidComparison(h(r), h(l.value)) ? null : [
-        new g(
-          this.replacePlaceholders(s, { newValue: r, oldValue: a, field: o, otherField: l }),
-          "",
-          "compare-to"
-        )
-      ]) : (o.markRecordIncomplete(), null);
-    };
-    super(i), this.isValidComparison = e, this.otherField = t;
-  }
-  isValidComparison;
-  otherField;
-  /**
-   * The fields this validator is registered on. Registration reaches one element at a time - the rows of a list
-   * take the validator on one by one, as they are built from the item template that carries it - so this is what
-   * says which of the fields a declaration stands for actually carry the rule, and a field that never took it on
-   * is left alone by a change of the compared field.
-   */
-  registrations = /* @__PURE__ */ new WeakSet();
-  /**
-   * The fields this validator has installed its listener on. A binding of such a field carries the listener too -
-   * a binding takes on the actions of the field it was bound from - so the field it was bound from is what is
-   * asked about as well, and a list of a thousand rows installs one listener rather than a thousand.
-   */
-  listening = /* @__PURE__ */ new WeakSet();
-  /**
-   * What the fields this validator was registered on were declared as. One entry stands for every binding of such a
-   * field, so a change of a compared field finds the fields of the record that change happened in without a list
-   * of a thousand rows being held here.
-   */
-  declarations = /* @__PURE__ */ new Set();
-  /** The field `field` is compared against, within the record `field` belongs to. */
-  resolve(t) {
-    const e = this.otherField;
-    return typeof e == "function" ? e(t) ?? void 0 : typeof e == "string" ? ae(e, t) : tt(e, V(t));
-  }
-  /**
-   * Makes a change of `other` re-run this comparison. The listener re-runs it over the fields of the record the
-   * change happened in rather than over the field that installed it, so the listener a row inherits with the field
-   * it was bound from serves that row; and it re-runs this one validator, not the chain around it.
-   */
-  listenOn(t) {
-    this.listening.has(t) || this.listening.has(t.declaration) || (this.listening.add(t), t.registerAction(
-      new P((e, s, i, r) => {
-        s(e, i, r);
-        const a = V(e);
-        this.declarations.forEach(
-          (o) => Pt(o, a).forEach((l) => {
-            this.registrations.has(l) && this.execute(l, () => null, l.value, this.comparisonState(l).oldValue);
-          })
-        );
-      })
-    ));
-  }
-  boundToBinding(t) {
-    this.declarations.add(t.declaration), this.registrations.add(t);
-  }
-  comparisonState(t) {
-    return this.bindingState(t);
-  }
-  newBindingState() {
-    return { ...super.newBindingState(), oldValue: void 0 };
-  }
-  unregisterFrom(t) {
-    super.unregisterFrom(t), this.registrations.delete(t);
-  }
-}
-class Te extends f {
-  constructor(t, e) {
-    const s = e || b("Must be one of [**{allowedAsText}**]"), i = () => {
-      const o = h(t);
-      return typeof o == "function" ? o() : o;
-    }, r = (o) => {
-      const l = o.join(", ");
-      return l.length <= 60 ? l : Xt(l, { length: 40, separator: ", ", omission: `... (${o.length} items total)` });
-    }, a = (o, l, v) => {
-      const p = i();
-      return p.includes(h(o)) ? null : [
-        new g(
-          this.replacePlaceholders(s, {
-            newValue: o,
-            oldValue: l,
-            field: v,
-            allowedValues: p,
-            allowedAsText: r(p)
-          }),
-          "",
-          "in-allowed-values"
-        )
-      ];
-    };
-    super(a);
-  }
-}
-function Oe(n) {
-  return n == null ? 0 : yt(n) || C(n) ? n.length : Et(n) && Object.getPrototypeOf(n) === Object.prototype ? Object.keys(n).length : String(n).length;
-}
-function wt(n) {
-  return typeof n == "object" && n !== null && !Vt(n) && !(n instanceof String) && !("componentName" in n);
-}
-class Pe extends f {
-  constructor(t, e) {
-    const s = wt(t) ? void 0 : t, i = (wt(t) ? t : e)?.trim ?? !0, r = s || b("Please enter a value"), a = (o, l, v) => {
-      const p = h(o);
-      return Oe(i && C(p) ? p.trim() : p) === 0 ? [
-        new g(
-          this.replacePlaceholders(r, { newValue: o, oldValue: l, field: v }),
-          "",
-          "required"
-        )
-      ] : null;
-    };
-    super(a);
-  }
-}
-class ke extends f {
-  constructor(t, e) {
-    const s = e || b("Value must be larger or equal to **{minValue}**"), i = (r, a, o) => r < t || r === void 0 ? [
-      new g(
-        this.replacePlaceholders(s, { newValue: r, oldValue: a, field: o, minValue: t }),
-        "",
-        "min"
-      )
-    ] : null;
-    super(i);
-  }
-}
-class Re extends f {
-  constructor(t, e) {
-    const s = e || b("Value must be less than or equal to **{maxValue}**"), i = (r, a, o) => r > t || r === void 0 ? [
-      new g(
-        this.replacePlaceholders(s, { newValue: r, oldValue: a, field: o, maxValue: t }),
-        "",
-        "max"
-      )
-    ] : null;
-    super(i);
-  }
-}
-class Fe extends f {
-  constructor(t, e, s) {
-    const i = s || b("Value must be between **{minValue}** and **{maxValue}**"), r = (a, o, l) => a < t || a > e || a === void 0 ? [
-      new g(
-        this.replacePlaceholders(i, { newValue: a, oldValue: o, field: l, minValue: t, maxValue: e }),
-        "",
-        "range"
-      )
-    ] : null;
-    super(r);
-  }
-}
-function st(n) {
-  return n == null ? 0 : yt(n) || C(n) ? n.length : Et(n) && Object.getPrototypeOf(n) === Object.prototype ? Object.keys(n).length : String(n).length;
-}
-class _e extends f {
-  constructor(t, e) {
-    const s = e || b("Length must be larger or equal to **{minLength}**"), i = (r, a, o) => st(r) < t ? [
-      new g(
-        this.replacePlaceholders(s, { newValue: r, oldValue: a, field: o, minLength: t }),
-        "",
-        "min-length"
-      )
-    ] : null;
-    super(i);
-  }
-}
-class je extends f {
-  constructor(t, e) {
-    const s = e || b("Length must be less than or equal to **{maxLength}**"), i = (r, a, o) => st(r) > t ? [
-      new g(
-        this.replacePlaceholders(s, { newValue: r, oldValue: a, field: o, maxLength: t }),
-        "",
-        "max-length"
-      )
-    ] : null;
-    super(i);
-  }
-}
-class Ne extends f {
-  constructor(t, e, s) {
-    const i = s || b("Length must be between **{minLength}** and **{maxLength}**"), r = (a, o, l) => {
-      const v = st(a);
-      return v < t || v > e ? [
-        new g(
-          this.replacePlaceholders(i, { newValue: a, oldValue: o, field: l, minLength: t, maxLength: e }),
-          "",
-          "range-length"
-        )
-      ] : null;
-    };
-    super(r);
-  }
-}
-class Be extends f {
-  constructor(t, e) {
-    const s = e || b('Value must match pattern "**{pattern}**"'), i = (r, a, o) => t.test(String(h(r))) ? null : [
-      new g(
-        this.replacePlaceholders(s, { newValue: r, oldValue: a, field: o, pattern: t }),
-        "",
-        "pattern"
-      )
-    ];
-    super(i);
-  }
-}
-const De = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
-  __proto__: null,
-  CompareTo: Ie,
-  InAllowedValues: Te,
-  LengthInRange: Ne,
-  MaxLength: je,
-  MaxValue: Re,
-  MinLength: _e,
-  MinValue: ke,
-  Pattern: Be,
-  Required: Pe,
-  Validator: f,
-  ValueInRange: Fe
-}, Symbol.toStringTag, { value: "Module" })), $e = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
-  __proto__: null,
-  AbortEventHandlingException: S,
-  Action: Se,
-  ActionsMap: x,
-  ConditionalEnabledAction: ue,
-  ConditionalStatementAction: U,
-  ConditionalValueAction: ce,
-  ConditionalVisibilityAction: le,
-  DisplayMode: O,
-  EnabledChangedAction: Rt,
-  EnabledChangingAction: kt,
-  ExecuteAction: Nt,
-  Field: et,
-  FieldActionBase: m,
-  FieldBase: y,
-  Group: d,
-  List: _,
-  ListItemAddedAction: Y,
-  ListItemRemovedAction: Bt,
-  MdString: N,
-  MessagesWidget: xe,
-  Operator: c,
-  RenderableValue: se,
-  Statement: w,
-  ValidChangedAction: Ft,
-  ValidationError: G,
-  ValidationErrorRenderContent: g,
-  ValidationErrorText: ee,
-  Validators: De,
-  ValueChangedAction: P,
-  VisibilityChangedAction: jt,
-  VisibilityChangingAction: _t,
-  buildErrorMessage: b,
-  defaultDisplayMode: Kt,
-  isCallableFunction: M,
-  isSimpleComponentDef: Z,
-  transaction: J
-}, Symbol.toStringTag, { value: "Module" }));
-export {
-  S as AbortEventHandlingException,
-  Se as Action,
-  x as ActionsMap,
-  ue as ConditionalEnabledAction,
-  U as ConditionalStatementAction,
-  ce as ConditionalValueAction,
-  le as ConditionalVisibilityAction,
-  O as DisplayMode,
-  Rt as EnabledChangedAction,
-  kt as EnabledChangingAction,
-  Nt as ExecuteAction,
-  et as Field,
-  m as FieldActionBase,
-  y as FieldBase,
-  d as Group,
-  _ as List,
-  Y as ListItemAddedAction,
-  Bt as ListItemRemovedAction,
-  N as MdString,
-  xe as MessagesWidget,
-  c as Operator,
-  se as RenderableValue,
-  w as Statement,
-  Ft as ValidChangedAction,
-  G as ValidationError,
-  g as ValidationErrorRenderContent,
-  ee as ValidationErrorText,
-  De as Validators,
-  P as ValueChangedAction,
-  jt as VisibilityChangedAction,
-  _t as VisibilityChangingAction,
-  b as buildErrorMessage,
-  $e as default,
-  Kt as defaultDisplayMode,
-  Ue as forms,
-  Gt as getConfig,
-  M as isCallableFunction,
-  Z as isSimpleComponentDef,
-  te as setConfig,
-  J as transaction
+function F(e) {
+	return P(u(Ee, e));
+}
+//#endregion
+//#region src/validators/validator.ts
+var Oe = Symbol("Validator"), ke = () => F("ValidationFailed"), I = class extends C {
+	source;
+	constructor(e) {
+		super((t, n, r, i) => {
+			let a = this.bindingState(t), o = a.abandon, s = ++a.run, ee = t.validationEpoch, c = he(), l = !1, u = () => !l && a.run === s && t.validationEpoch === ee && !c?.rolledBack, d = new AbortController(), f = () => {
+				u() || (l = !0, a.abandon === f && (a.abandon = void 0), d.abort());
+			};
+			o?.();
+			let p = e(r, i, t, d.signal) || [], m = (e) => D(() => {
+				let n = e?.map((e) => this.claim(e)) ?? [];
+				for (let e = t.errors.length - 1; e >= 0; e--) {
+					let r = t.errors[e];
+					if (r.source === this.source) {
+						let i = n.findIndex((e) => e.sameAs(r));
+						i >= 0 ? n.splice(i, 1) : t.errors.splice(e, 1);
+					}
+				}
+				n.length > 0 && t.errors.push(...n), t.validate();
+			});
+			return p instanceof Promise ? (a.abandon = f, c?.whenRolledBack(f), t.beginValidating(), p.then((e) => {
+				u() && m(e);
+			}, (e) => {
+				u() && (m([new N(ke(), "", "validation-failed")]), console.error("Validation failed", e));
+			}).finally(() => {
+				a.abandon === f && (a.abandon = void 0), t.endValidating();
+			}).catch((e) => console.error("Validation failed", e))) : m(p), n(t, r, i);
+		}), this.source = Symbol(this.constructor.name);
+	}
+	claim(e) {
+		let t = e.source;
+		if (t === this.source) return e;
+		let n = {
+			value: this.source,
+			enumerable: !1,
+			configurable: !1
+		};
+		if (t === void 0) return Object.defineProperty(e, "source", n), e;
+		let r = Object.getOwnPropertyDescriptors(e);
+		return Object.create(Object.getPrototypeOf(e), {
+			...r,
+			source: n
+		});
+	}
+	static get classIdentifier() {
+		return Oe;
+	}
+	get eager() {
+		return !0;
+	}
+	unregisterFrom(e) {
+		O((t) => {
+			t.whenCommitted(() => this.abandonRun(e));
+			for (let t = e.errors.length - 1; t >= 0; t--) e.errors[t].source === this.source && e.errors.splice(t, 1);
+			e.validate();
+		});
+	}
+	abandonRun(e) {
+		this.bindingState(e).abandon?.();
+	}
+	bindingState(e) {
+		return this.state(e, () => this.newBindingState());
+	}
+	newBindingState() {
+		return { run: 0 };
+	}
+	replacePlaceholdersFunction(e, t) {
+		return () => {
+			let n = d(e);
+			for (; j(n);) n = d(this.replacePlaceholders(n(), t));
+			return n;
+		};
+	}
+	replacePlaceholders(e, n) {
+		if (j(e)) return this.replacePlaceholdersFunction(e, n);
+		if (A(e)) return e;
+		if (o(e)) return this.replacePlaceholdersFunction(() => d(e), n);
+		let r = d(e), i = t(r.toString(), n);
+		return r instanceof k ? new k(i, r.options, r.plugins) : i;
+	}
+}, L = class e {
+	actions = [];
+	register(e, t) {
+		if (!(e instanceof x)) throw Error("Invalid action type");
+		let n = t ? this.actions.indexOf(t) : -1;
+		if (t && (t.classIdentifier !== e.classIdentifier || n < 0)) throw Error("Action to register before is not registered under the same identifier");
+		n < 0 ? this.actions.push(e) : this.actions.splice(n, 0, e);
+	}
+	unregister(e) {
+		return this.actions.includes(e) ? (this.actions = this.actions.filter((t) => t !== e), !0) : !1;
+	}
+	willTrigger(e) {
+		return this.actions.some((t) => t.classIdentifier === e);
+	}
+	get hasEager() {
+		return this.actions.some((e) => e.eager);
+	}
+	trigger(e, t, ...n) {
+		return this.run(e.classIdentifier, !1, t, n);
+	}
+	triggerEager(t, ...n) {
+		let r = this.actions;
+		for (let i = r.length - 1; i >= 0; i--) {
+			let a = r[i];
+			if (a.eager && e.outermostEager(r, i)) try {
+				let o = this.walk(r, i, a.classIdentifier, !0, t, n);
+				e.isPromise(o) && o.then(void 0, (e) => {
+					if (!(e instanceof S)) throw e;
+				});
+			} catch (e) {
+				if (!(e instanceof S)) throw e;
+			}
+		}
+	}
+	triggerEagerFor(e, t, ...n) {
+		return this.run(e, !0, t, n);
+	}
+	get validators() {
+		return this.actions.filter((e) => e instanceof I);
+	}
+	bindTo(e) {
+		this.actions.forEach((t) => t.boundToBinding(e));
+	}
+	static outermostEager(e, t) {
+		let n = e[t].classIdentifier;
+		for (let r = e.length - 1; r > t; r--) if (e[r].eager && e[r].classIdentifier === n) return !1;
+		return !0;
+	}
+	static isPromise(e) {
+		return e instanceof Promise;
+	}
+	static answerAbort(t) {
+		return e.isPromise(t) ? t.then(void 0, (e) => {
+			if (e instanceof S) return e;
+			throw e;
+		}) : t;
+	}
+	run(t, n, r, i) {
+		let a = this.actions;
+		try {
+			return e.answerAbort(this.walk(a, a.length - 1, t, n, r, i));
+		} catch (e) {
+			if (e instanceof S) return e;
+			throw e;
+		}
+	}
+	walk(e, t, n, r, i, a) {
+		let o = t;
+		for (; o >= 0 && (e[o].classIdentifier !== n || r && !e[o].eager);) o--;
+		return o < 0 ? null : e[o].execute(i, (t, ...i) => this.walk(e, o - 1, n, r, t, i), ...a);
+	}
 };
-//# sourceMappingURL=dynamicforms-vue-forms.js.map
+//#endregion
+//#region src/binding/resolve.ts
+function R(e) {
+	let t = e;
+	for (; t.fieldName !== void 0 && t.parent;) t = t.parent;
+	return t;
+}
+function Ae(e, t) {
+	let n = e;
+	for (let e of je(t)) if (n = n.field?.(e) ?? void 0, !n) return;
+	return n?.declaration === t ? n : void 0;
+}
+function je(e) {
+	let t = [], n = e;
+	for (; n.fieldName !== void 0 && n.parent;) t.unshift(n.fieldName), n = n.parent;
+	return t;
+}
+function Me(e, t) {
+	let n = Ae(t, e);
+	if (n) return n;
+	let r = t.parent;
+	for (; r;) {
+		let t = Ae(R(r), e);
+		if (t) return t;
+		r = r.parent;
+	}
+	return R(e) === R(t.declaration) ? void 0 : e;
+}
+function Ne(e, t) {
+	let n = Me(e, t);
+	if (!n) return [];
+	if (n !== e) return [n];
+	let r = t.bindingsOf(e);
+	return r.length > 0 ? r : [e];
+}
+function Pe(e, t) {
+	let n = t.parent;
+	for (; n;) {
+		let t = n.field?.(e);
+		if (t) return t;
+		n = n.parent;
+	}
+}
+//#endregion
+//#region src/actions/conditional/conditional-statement-action.ts
+var Fe = Symbol("ConditionalStatementAction"), z = class extends C {
+	statement;
+	conditionalExecutor;
+	declarations = /* @__PURE__ */ new Set();
+	registrations = /* @__PURE__ */ new WeakSet();
+	constructor(e, t) {
+		super((e, t, n, r) => (this.applyIn(R(e)) || e.markRecordIncomplete(), t(e, n, r))), this.statement = e, this.conditionalExecutor = t;
+		let n = new C((e, t, ...n) => (this.applyFrom(e), t(e, ...n)));
+		e.collectFields().forEach((e) => e.registerAction(n));
+	}
+	static get classIdentifier() {
+		return Fe;
+	}
+	get eager() {
+		return !0;
+	}
+	boundToBinding(e) {
+		this.declarations.add(e.declaration), this.registrations.add(e);
+	}
+	unregisterFrom(e) {
+		this.registrations.delete(e);
+	}
+	targetsIn(e) {
+		let t = [];
+		return this.declarations.forEach((n) => Ne(n, e).forEach((e) => {
+			this.registrations.has(e) && t.push(e);
+		})), t;
+	}
+	applyIn(e) {
+		let t = this.targetsIn(e);
+		if (t.length === 0) return !1;
+		let n = this.state(e, () => ({ lastResult: void 0 })), r = this.statement.evaluate(e);
+		if (r === n.lastResult) return !0;
+		let i = n.lastResult;
+		return n.lastResult = r, t.forEach((e) => this.conditionalExecutor(e, r, i)), !0;
+	}
+	applyFrom(e) {
+		let t = /* @__PURE__ */ new Set();
+		this.targetsIn(R(e)).forEach((e) => t.add(R(e))), t.forEach((e) => this.applyIn(e));
+	}
+}, Ie = class extends z {
+	constructor(e) {
+		super(e, (e, t) => {
+			e.visibility = t ? b.FULL : b.SUPPRESS;
+		});
+	}
+}, Le = class extends z {
+	constructor(e) {
+		super(e, (e, t) => {
+			e.enabled = t;
+		});
+	}
+}, Re = class extends z {
+	constructor(e, t) {
+		super(e, (e, n) => {
+			n && (e.value = t);
+		});
+	}
+}, B = /* @__PURE__ */ function(e) {
+	return e[e.NOT = 0] = "NOT", e[e.OR = 1] = "OR", e[e.AND = 2] = "AND", e[e.XOR = 3] = "XOR", e[e.NAND = 4] = "NAND", e[e.NOR = 5] = "NOR", e[e.EQUALS = -1] = "EQUALS", e[e.NOT_EQUALS = -2] = "NOT_EQUALS", e[e.GT = -3] = "GT", e[e.LT = -4] = "LT", e[e.GE = -5] = "GE", e[e.LE = -6] = "LE", e[e.IN = -7] = "IN", e[e.NOT_IN = -8] = "NOT_IN", e[e.INCLUDES = -9] = "INCLUDES", e[e.NOT_INCLUDES = -10] = "NOT_INCLUDES", e;
+}(B || {});
+(function(e) {
+	function t(e) {
+		let t = e.toLowerCase();
+		if (t === "not") return 0;
+		if (t === "or") return 1;
+		if (t === "and") return 2;
+		if (t === "xor") return 3;
+		if (t === "nand") return 4;
+		if (t === "nor") return 5;
+		if (t === "equals") return -1;
+		if ([
+			"not_equals",
+			"not-equals",
+			"not equals"
+		].includes(t)) return -2;
+		if (t === "gt") return -3;
+		if (t === "lt") return -4;
+		if (t === "ge") return -5;
+		if (t === "le") return -6;
+		if (t === "in") return -7;
+		if ([
+			"not_in",
+			"not-in",
+			"not in"
+		].includes(t)) return -8;
+		if (t === "includes") return -9;
+		if ([
+			"not_includes",
+			"not-includes",
+			"not includes"
+		].includes(t)) return -10;
+		throw Error(`Unrecognised operator ${t}`);
+	}
+	e.fromString = t;
+	function n(e) {
+		let t = typeof e == "number" ? e : B.fromString(e);
+		if (Object.values(B).includes(t)) return t;
+		throw Error(`Unrecognised operator ${e}`);
+	}
+	e.fromAny = n;
+	function r(e) {
+		let t = typeof e == "number" ? e : B.fromString(e);
+		return Object.values(B).includes(t);
+	}
+	e.isDefined = r;
+	function i(e) {
+		return e >= 0;
+	}
+	e.isLogicOperator = i;
+})(B ||= {}), Object.freeze(B);
+var V = B, ze = Symbol("EnabledChangingAction"), H = class extends x {
+	constructor(e) {
+		super(e);
+	}
+	static get classIdentifier() {
+		return ze;
+	}
+	execute(e, t, n, r) {
+		return super.execute(e, t, n, r);
+	}
+}, Be = Symbol("EnabledChangedAction"), U = class extends x {
+	constructor(e) {
+		super(e);
+	}
+	static get classIdentifier() {
+		return Be;
+	}
+	execute(e, t, n, r) {
+		return super.execute(e, t, n, r);
+	}
+}, Ve = Symbol("ValidChangedAction"), W = class extends x {
+	constructor(e) {
+		super(e);
+	}
+	static get classIdentifier() {
+		return Ve;
+	}
+	execute(e, t, n, r) {
+		return super.execute(e, t, n, r);
+	}
+}, He = Symbol("VisibilityChangingAction"), G = class extends x {
+	constructor(e) {
+		super(e);
+	}
+	static get classIdentifier() {
+		return He;
+	}
+	execute(e, t, n, r) {
+		return super.execute(e, t, n, r);
+	}
+}, Ue = Symbol("VisibilityChangedAction"), K = class extends x {
+	constructor(e) {
+		super(e);
+	}
+	static get classIdentifier() {
+		return Ue;
+	}
+	execute(e, t, n, r) {
+		return super.execute(e, t, n, r);
+	}
+}, We = /* @__PURE__ */ new WeakMap(), Ge = /* @__PURE__ */ new WeakMap(), q = /* @__PURE__ */ new WeakMap(), Ke = /* @__PURE__ */ new Set(["validators", "actions"]), J = 0, Y = class {
+	get __v_skip() {
+		return !0;
+	}
+	get __v_isReactive() {
+		return !0;
+	}
+	get [Symbol.toStringTag]() {
+		return "FormElement";
+	}
+	#e;
+	#t;
+	constructor(e) {
+		this.#t = e, this.#e = ee(e);
+	}
+	get state() {
+		return this.#e;
+	}
+	get raw() {
+		return this.#t;
+	}
+	rebind(e) {
+		return O((t) => {
+			t.touch(this);
+			let n = t.willAnnounceValue(this), r = this.#t.announcedValue;
+			this.resetTo(this.declaration, e), this.#t.announcedValue = n ? r : this.value;
+		}), this;
+	}
+	get originalValue() {
+		return this.#e.originalValue;
+	}
+	set originalValue(e) {
+		this.touchState(), this.#e.originalValue = e;
+	}
+	get extra() {
+		return this.#e.extra;
+	}
+	setExtendedValues(e) {
+		this.touchState(), this.#e.extra = Object.freeze({
+			...this.#t.extra,
+			...e
+		});
+	}
+	extendedOf(e) {
+		let t = Object.create(null);
+		return Object.entries(e).forEach(([e, n]) => {
+			Ke.has(e) || (!(e in this) || Object.hasOwn(Object.prototype, e)) && (t[e] = n);
+		}), t;
+	}
+	assignParams(e) {
+		let t = this.extendedOf(e);
+		Object.entries(e).forEach(([e, n]) => {
+			Object.hasOwn(t, e) || Ke.has(e) || (this[e] = n);
+		}), h(t) || this.setExtendedValues(t);
+	}
+	touchState() {
+		he()?.touch(this);
+	}
+	[w]() {
+		return {
+			...this.#t,
+			errors: [...this.#t.errors]
+		};
+	}
+	[le](e) {
+		let t = this.#t.validatingCount, n = this.#t.validatingChildren;
+		Object.assign(this.#e, e), this.#e.validatingCount = t, this.#e.validatingChildren = n;
+	}
+	get validating() {
+		return this.#e.validatingCount > 0 || this.#e.validatingChildren > 0;
+	}
+	beginValidating() {
+		let e = !this.validating;
+		this.#e.validatingCount++, e && this.container?.childValidatingChanged(!0);
+	}
+	endValidating() {
+		this.#t.validatingCount !== 0 && (this.#e.validatingCount--, this.validating || this.container?.childValidatingChanged(!1));
+	}
+	childValidatingChanged(e) {
+		let t = this.validating;
+		this.#e.validatingChildren += e ? 1 : -1, this.validating !== t && this.container?.childValidatingChanged(e);
+	}
+	get busy() {
+		return !1;
+	}
+	get busyRead() {
+		let e = Ge.get(this);
+		return e || (e = n(() => this.composeBusy()), Ge.set(this, e)), e.value;
+	}
+	composeBusy() {
+		return !1;
+	}
+	settled() {
+		return !this.validating && !this.busy ? Promise.resolve() : new Promise((e) => {
+			let t = f(() => this.validating || this.busy, (n) => {
+				n || (t(), e());
+			}, { flush: "sync" });
+		});
+	}
+	get errors() {
+		return this.touchState(), this.#e.errors;
+	}
+	set errors(e) {
+		this.touchState(), this.#e.errors = e;
+	}
+	get parent() {
+		return this.#e.parent;
+	}
+	get container() {
+		return this.#e.parent;
+	}
+	get fieldName() {
+		return this.#e.fieldName;
+	}
+	get declaration() {
+		return this.#t.declaration ?? this;
+	}
+	get members() {
+		return [];
+	}
+	bindingsOf(e) {
+		let t = e.declaration, n = [], r = (e) => {
+			e.declaration === t && n.push(e), e.members.forEach(r);
+		};
+		return r(this), n;
+	}
+	markRecordIncomplete() {
+		this._recordPending || (this._recordPending = !0, J++);
+	}
+	completeRecords(e = this) {
+		J !== 0 && O(() => {
+			let t = (e) => {
+				e._recordPending && (e._recordPending = !1, J--, e.rerunEagerActions()), e.members.forEach(t);
+			};
+			t(e);
+		});
+	}
+	rerunEagerActions() {
+		O((e) => {
+			this.boundActions?.triggerEager(this, this.value, this.value), e.markValidityDirty(this);
+		});
+	}
+	get boundActions() {
+		return this._actions;
+	}
+	noteBinding(e) {
+		let t = q.get(this);
+		t || (t = /* @__PURE__ */ new Set(), q.set(this, t)), t.add(new WeakRef(e));
+	}
+	get boundElements() {
+		let e = this.declaration, t = q.get(e), n = [e];
+		return t && t.forEach((e) => {
+			let r = e.deref();
+			r ? n.push(r) : t.delete(e);
+		}), n;
+	}
+	get actions() {
+		let e = this.declaration;
+		if (!e._actions) {
+			let t = new L();
+			e.boundElements.forEach((e) => {
+				e._actions = t;
+			});
+		}
+		return e._actions;
+	}
+	get valueVersion() {
+		return this.#e.valueVersion;
+	}
+	bumpValueVersion() {
+		O((e) => {
+			e.touch(this), this.#e.valueVersion++;
+			let t = this.parent;
+			for (; t;) e.touch(t), t.#e.valueVersion++, t = t.parent;
+		});
+	}
+	propagateValueChanged(e = !1) {
+		O((t) => {
+			t.markValueChanged(this, e), t.markValidityDirty(this), this.parent?.notifyValueChanged();
+		});
+	}
+	constructed(e) {}
+	refreshPreviousValue() {}
+	get countedValid() {
+		return this.#t.errors.length === 0 && this.#t.invalidChildren === 0;
+	}
+	takeChild(e, t) {
+		O((n) => {
+			if (e.parent) throw TypeError("This element already belongs to a container - pass a bind() of it");
+			n.touch(e), e.#e.fieldName = t, e.#e.parent = this, this.adoptChild(e);
+		});
+	}
+	adoptChild(e) {
+		O((t) => {
+			t.touch(this), e.#t.valid || this.#t.invalidChildren++, e.validating && this.childValidatingChanged(!0), t.whenRolledBack(() => {
+				e.validating && this.childValidatingChanged(!1);
+			}), t.markValidityDirty(this);
+		});
+	}
+	releaseChild(e) {
+		O((t) => {
+			t.touch(this), t.touch(e), e.#t.valid || this.#t.invalidChildren--, e.validating && this.childValidatingChanged(!1), t.whenRolledBack(() => {
+				e.validating && this.childValidatingChanged(!0);
+			}), e.#e.parent = void 0, e.#e.fieldName = void 0, t.markValidityDirty(this);
+		});
+	}
+	resetTo(e, t) {
+		O(() => {
+			let n = t === void 0 ? e.value : t, r = this.errors.length > 0;
+			r && (this.errors = []), this.touched = !1;
+			let i = this.enabled && this.value !== n;
+			this.value = n, this.originalValue = this.value, this.validate(!i && r);
+		});
+	}
+	resetChild(e, t, n) {
+		e.resetTo(t, n);
+	}
+	childValidityChanged(e) {
+		this.#t.invalidChildren += e ? -1 : 1;
+	}
+	get validRead() {
+		let e = We.get(this);
+		return e || (e = n(() => this.composeValid()), We.set(this, e)), e.value;
+	}
+	composeValid() {
+		return this.#e.errors.length === 0;
+	}
+	get visibility() {
+		return this.#e.visibility;
+	}
+	set visibility(e) {
+		let t = this.#e.visibility;
+		e !== t && O((n) => {
+			let r = this.boundActions?.trigger(G, this, e, t);
+			if (!(r instanceof S)) {
+				if (!b.isDefined(r ?? e)) throw Error("visibility must be a DisplayMode constant");
+				n.touch(this), this.#e.visibility = b.fromAny(r ?? e), this.boundActions?.trigger(K, this, this.#e.visibility, t);
+			}
+		});
+	}
+	get enabled() {
+		return this.#e.enabled;
+	}
+	set enabled(e) {
+		let t = this.#e.enabled;
+		e !== t && O((n) => {
+			let r = this.boundActions?.trigger(H, this, e, t);
+			if (!(r instanceof S)) {
+				if (!m(r ?? e)) throw Error("Enabled value must be boolean");
+				n.touch(this), this.#e.enabled = r ?? e, this.#e.enabled !== t && this.bumpValueVersion(), this.boundActions?.trigger(U, this, this.#e.enabled, t);
+			}
+		});
+	}
+	get effectiveEnabled() {
+		return this.enabled && (this.parent?.effectiveEnabled ?? !0);
+	}
+	get composesValue() {
+		return !1;
+	}
+	childComposesValue(e) {
+		return e.composesValue;
+	}
+	[ue](e, t, n, r) {
+		if (r?.forEach((e) => this.boundActions?.trigger(e.actionClass, this, e.item, e.index)), !t) return;
+		let i = this.boundActions;
+		if (this.composesValue && !(i?.willTrigger(ce) || i?.hasEager)) return;
+		let a = this.value, o = this.#t.announcedValue;
+		!n && (this.composesValue ? g(a, o) : a === o) || (e.touch(this), this.#t.announcedValue = a, this.composesValue && i?.triggerEager(this, a, o), i?.trigger(C, this, a, o));
+	}
+	[de](e) {
+		let t = this.#t.valid, n = this.countedValid;
+		if (n === t) return;
+		e.touch(this), this.#t.valid = n;
+		let r = this.container;
+		r && (e.touch(r), r.childValidityChanged(n), e.markValidityDirty(r)), this.boundActions?.trigger(W, this, n, t);
+	}
+	validate(e = !1) {
+		O((t) => {
+			e && this.boundActions?.triggerEager(this, this.value, this.value), t.markValidityDirty(this);
+		});
+	}
+	get valid() {
+		return this.#e.errors.length === 0;
+	}
+	get fullValue() {
+		return this.value;
+	}
+	get isChanged() {
+		return !g(this.value, this.originalValue);
+	}
+	boundFrom(e, t, n, r) {
+		this.#t.declaration = e.declaration;
+		let i = {
+			...e.extra,
+			...r && this.extendedOf(r)
+		};
+		h(i) || this.setExtendedValues(i);
+		let a = this.declaration;
+		a.noteBinding(this);
+		let o = a._actions;
+		o && (this._actions = o, o.bindTo(this), o.triggerEager(this, t, n));
+	}
+	registerInitialActions(e) {
+		e.forEach((e) => {
+			this.actions.register(e), e.boundToBinding(this);
+		});
+	}
+	registerAction(e) {
+		return O((t) => {
+			t.willAnnounceValue(this) || this.refreshPreviousValue(), this.actions.register(e), this.registered(t, e);
+		}), this;
+	}
+	registerActionBefore(e, t) {
+		return O((n) => {
+			n.willAnnounceValue(this) || this.refreshPreviousValue(), this.actions.register(e, t), this.registered(n, e);
+		}), this;
+	}
+	unregisterAction(e) {
+		let t = !1;
+		return O((n) => {
+			let r = this.boundActions;
+			if (!r || (t = r.unregister(e), !t)) return;
+			n.touch(this), e instanceof I && this.#e.validationEpoch++;
+			let i = this.boundElements;
+			n.whenRolledBack(() => {
+				r.register(e), i.forEach((t) => e.boundToBinding(t));
+			}), i.forEach((t) => e.unregisterFrom(t));
+		}), t;
+	}
+	registered(e, t) {
+		let n = this.boundElements;
+		n.forEach((e) => {
+			t.boundToBinding(e), t.eager && this.actions.triggerEagerFor(t.classIdentifier, e, e.value, e.originalValue);
+		}), e.whenRolledBack(() => {
+			this.boundActions?.unregister(t) && n.forEach((e) => t.unregisterFrom(e));
+		});
+	}
+	triggerAction(e, ...t) {
+		let n = this.boundActions;
+		return n ? n.trigger(e, this, ...t) : null;
+	}
+	get validationEpoch() {
+		return this.#e.validationEpoch;
+	}
+	clearValidators() {
+		O((e) => {
+			e.touch(this), this.#e.validationEpoch++;
+			let t = this.boundActions;
+			if (t) {
+				let n = this.boundElements;
+				t.validators.forEach((r) => {
+					t.unregister(r), e.whenRolledBack(() => {
+						t.register(r), n.forEach((e) => r.boundToBinding(e));
+					}), n.forEach((e) => r.unregisterFrom(e));
+				});
+			}
+			this.errors = [], this.validate();
+		});
+	}
+};
+//#endregion
+//#region src/actions/conditional/statement.ts
+function qe(e, t) {
+	return e ? !t : t;
+}
+var Je = class e {
+	operand1;
+	operator;
+	operand2;
+	static validateOperand(e, t) {
+		if (e === void 0) throw TypeError(`Statement operand ${t} is undefined: an operand is a field, a nested statement or a literal, and a name resolving to nothing is none of them. Compare against null to test for an unset value.`);
+		if (typeof e == "function") throw TypeError(`Statement operand ${t} is a function: an operand is a field, a nested statement or a literal, and a function is none of them. An accessor states the field it answers with: group.field('name').`);
+	}
+	constructor(t, n, r) {
+		e.validateOperand(t, 1), n !== V.NOT && e.validateOperand(r, 2), this.operand1 = t, this.operator = n, this.operand2 = r;
+	}
+	static valueOf(t, n) {
+		if (t instanceof e) return t.evaluate(n);
+		if (t instanceof Y) {
+			let e = n ? Me(t, n) : t;
+			return e ? d(e.value) : void 0;
+		}
+		return t;
+	}
+	get operand1Value() {
+		return e.valueOf(this.operand1);
+	}
+	get operand2Value() {
+		return e.valueOf(this.operand2);
+	}
+	evaluate(t) {
+		let n = e.valueOf(this.operand1, t), r = e.valueOf(this.operand2, t);
+		switch (this.operator) {
+			case V.AND: return !!(n && r);
+			case V.OR: return !!(n || r);
+			case V.NAND: return !(n && r);
+			case V.NOR: return !(n || r);
+			case V.XOR: return qe(!!n, !!r);
+			case V.NOT: return !n;
+			case V.EQUALS: return n == r;
+			case V.NOT_EQUALS: return n != r;
+			case V.LT: return n < r;
+			case V.LE: return n <= r;
+			case V.GE: return n >= r;
+			case V.GT: return n > r;
+			case V.IN: return !!r?.includes?.(n);
+			case V.NOT_IN: return !r?.includes?.(n);
+			case V.INCLUDES: return _(n) && _(r) && n.indexOf(r) >= 0;
+			case V.NOT_INCLUDES: return !(_(n) && _(r) && n.indexOf(r) >= 0);
+			default: throw Error(`Operator not implemented ${this.operator}`);
+		}
+	}
+	collectFields() {
+		let t = /* @__PURE__ */ new Set();
+		function n(n) {
+			n instanceof Y ? t.add(n) : n instanceof e && n.collectFields().forEach((e) => t.add(e));
+		}
+		return n(this.operand1), n(this.operand2), t;
+	}
+}, Ye = Symbol("ExecuteAction"), X = class extends x {
+	constructor(e) {
+		super(e);
+	}
+	static get classIdentifier() {
+		return Ye;
+	}
+	execute(e, t, n) {
+		return super.execute(e, t, n);
+	}
+}, Xe = Symbol("ListItemAddedAction"), Z = class extends x {
+	constructor(e) {
+		super(e);
+	}
+	static get classIdentifier() {
+		return Xe;
+	}
+	execute(e, t, n, r) {
+		return super.execute(e, t, n, r);
+	}
+}, Ze = Symbol("ListItemRemovedAction"), Qe = class extends x {
+	constructor(e) {
+		super(e);
+	}
+	static get classIdentifier() {
+		return Ze;
+	}
+	execute(e, t, n, r) {
+		return super.execute(e, t, n, r);
+	}
+}, $e = Object.freeze({});
+function et() {
+	return {
+		originalValue: void 0,
+		announcedValue: void 0,
+		errors: [],
+		visibility: b.FULL,
+		enabled: !0,
+		valueVersion: 0,
+		validatingCount: 0,
+		validatingChildren: 0,
+		parent: void 0,
+		fieldName: void 0,
+		validationEpoch: 0,
+		declaration: void 0,
+		extra: $e,
+		valid: !0,
+		invalidChildren: 0
+	};
+}
+function tt() {
+	return {
+		...et(),
+		value: void 0,
+		touched: !1
+	};
+}
+function nt() {
+	return {
+		...et(),
+		announcedValue: null,
+		cachedValue: null,
+		cachedValueVersion: -1
+	};
+}
+function rt() {
+	return {
+		...nt(),
+		fieldNames: []
+	};
+}
+function it() {
+	return {
+		...nt(),
+		rows: null,
+		rowsVersion: 0,
+		cachedItems: null,
+		cachedItemsVersion: -1
+	};
+}
+//#endregion
+//#region src/field.ts
+var Q = class extends Y {
+	get [Symbol.toStringTag]() {
+		return "Field";
+	}
+	get state() {
+		return super.state;
+	}
+	get raw() {
+		return super.raw;
+	}
+	get _value() {
+		return this.state.value;
+	}
+	set _value(e) {
+		this.state.value = e;
+	}
+	constructor(e) {
+		super(tt()), this.init(e);
+	}
+	init(e) {
+		O(() => {
+			if (e) {
+				let { value: t, validators: n, actions: r, ...i } = e;
+				this.registerInitialActions([...n || [], ...r || []]), this.assignParams(i), this._value = t === void 0 ? this.originalValue : t;
+			}
+			this.constructed(e), this.originalValue === void 0 && (this.originalValue = this._value), this.raw.announcedValue = this._value, this.boundActions?.triggerEager(this, this.value, this.originalValue), this.validate();
+		});
+	}
+	get value() {
+		return this._value;
+	}
+	set value(e) {
+		let t = this._value;
+		!this.enabled || t === e || O((n) => {
+			n.touch(this), this._value = e, this.bumpValueVersion(), this.boundActions?.triggerEager(this, e, t), this.propagateValueChanged();
+		});
+	}
+	get parent() {
+		return super.parent;
+	}
+	get touched() {
+		return this.state.touched;
+	}
+	set touched(e) {
+		this.touchState(), this.state.touched = e;
+	}
+	bind(e, t) {
+		let n = this.constructor, r = new n({
+			value: e === void 0 ? this.value : e,
+			...t && "originalValue" in t ? { originalValue: t.originalValue } : {},
+			enabled: t?.enabled ?? this.enabled,
+			visibility: t?.visibility ?? this.visibility
+		});
+		return r.boundFrom(this, r.value, r.originalValue, t), r;
+	}
+}, at = /* @__PURE__ */ new WeakMap();
+function ot(e) {
+	if (e != null) return Object.values(e).some((e) => e != null) ? e : void 0;
+}
+var st = class extends Q {
+	get [Symbol.toStringTag]() {
+		return "Action";
+	}
+	init(e) {
+		O(() => {
+			if (this._value = {
+				label: void 0,
+				icon: void 0
+			}, e) {
+				let { value: t, originalValue: n, validators: r, actions: i, ...a } = e;
+				this.registerInitialActions([...r || [], ...i || []]), this.assignParams(a);
+				let o = ot(t), s = ot(n);
+				o ? this._value = o : s && (this._value = { ...s }), s && (this.originalValue = Object.freeze({ ...s }));
+			}
+			this.constructed(e), this.originalValue === void 0 && (this.originalValue = this._value), this.raw.announcedValue = this._value, this.boundActions?.triggerEager(this, this.value, this.originalValue), this.validate();
+		});
+	}
+	valueWith(e, t) {
+		let n = { ...this.value };
+		return t === void 0 ? delete n[e] : n[e] = t, n;
+	}
+	get icon() {
+		return this.value.icon;
+	}
+	set icon(e) {
+		this.value.icon !== e && (this.value = this.valueWith("icon", e));
+	}
+	get label() {
+		return this.value.label;
+	}
+	set label(e) {
+		this.value.label !== e && (this.value = this.valueWith("label", e));
+	}
+	get busyRuns() {
+		let e = at.get(this);
+		return e || (e = c(0), at.set(this, e)), e;
+	}
+	get busy() {
+		return this.busyRuns.value > 0;
+	}
+	async execute(e) {
+		let t = this.busyRuns;
+		t.value++;
+		try {
+			return await this.triggerAction(X, e);
+		} finally {
+			t.value--;
+		}
+	}
+}, ct = /* @__PURE__ */ i({
+	__name: "messages-widget",
+	props: {
+		message: {},
+		classes: {}
+	},
+	setup(e) {
+		let t = e, n = l("vue-markdown"), i = /* @__PURE__ */ new Set(/* @__PURE__ */ "div.span.p.h1.h2.h3.h4.h5.h6.section.article.aside.nav.header.footer.main.figure.figcaption.blockquote.pre.code.em.strong.small.mark.del.ins.sub.sup.i.b.u.s.a.img.button.input.textarea.select.option.label.form.table.tr.td.th.thead.tbody.tfoot.ul.ol.li.dl.dt.dd".split(".")), o = () => {
+			if (typeof t.message == "string") return a("span", { class: t.classes }, t.message);
+			let e = [];
+			return t.message.forEach((r) => {
+				switch (r.componentName) {
+					case "template":
+						e.push(a("div", { class: [t.classes, r.extraClasses] }, r.componentBody));
+						break;
+					case "vue-markdown":
+						if (typeof n == "string") console.warn("You are using markdown for messages-widget, but you haven't registered a vue-markdown component"), e.push(a("div", { class: [t.classes, r.extraClasses] }, r.componentBindings.source));
+						else {
+							let i = r.componentBindings;
+							e.push(a(n, {
+								class: [
+									t.classes,
+									r.extraClasses,
+									"df-messages-widget-markdown"
+								],
+								source: i.source,
+								options: i.options,
+								plugins: i.plugins
+							}));
+						}
+						break;
+					default: e.push(a(i.has(r.componentName.toLowerCase()) ? r.componentName : l(r.componentName), {
+						class: [t.classes, r.extraClasses],
+						...r.componentBindings,
+						...r.componentBody ? { innerHTML: r.componentBody } : {}
+					}));
+				}
+			}), e;
+		};
+		return (e, t) => (s(), r(o));
+	}
+}), lt = /* @__PURE__ */ new WeakMap(), ut = (e) => ({
+	get(t, n, r) {
+		return e(), Reflect.get(t, n, r);
+	},
+	has(t, n) {
+		return e(), Reflect.has(t, n);
+	},
+	ownKeys(t) {
+		return e(), Reflect.ownKeys(t);
+	},
+	getOwnPropertyDescriptor(t, n) {
+		return e(), Reflect.getOwnPropertyDescriptor(t, n);
+	},
+	set(e, t) {
+		throw TypeError(`fields.${String(t)} cannot be assigned: use addField() to give the group a member`);
+	},
+	defineProperty(e, t) {
+		throw TypeError(`fields.${String(t)} cannot be redefined: use addField() to give the group a member`);
+	},
+	deleteProperty(e, t) {
+		throw TypeError(`fields.${String(t)} cannot be deleted: use removeField() to take a member out`);
+	}
+}), $ = class e extends Y {
+	get [Symbol.toStringTag]() {
+		return "Group";
+	}
+	get state() {
+		return super.state;
+	}
+	get raw() {
+		return super.raw;
+	}
+	_fields;
+	constructor(t, n) {
+		if (super(rt()), !e.isValidFields(t)) throw Error("Invalid fields object provided");
+		this._fields = Object.create(null), O(() => {
+			if (Object.entries(t).forEach(([e, t]) => this.addField(e, t)), n) {
+				let { value: e, validators: t, actions: r, ...i } = n;
+				this.registerInitialActions([...t || [], ...r || []]), this.assignParams(i), e === void 0 ? this.originalValue !== void 0 && this.assignMembers(this.originalValue) : this.assignMembers(e);
+			}
+			this.completeRecords(), this.constructed(n);
+			let r = this.value;
+			this.originalValue === void 0 && (this.originalValue = e.baseline(r)), this.raw.announcedValue = r, this.boundActions?.triggerEager(this, r, this.originalValue), this.validate();
+		});
+	}
+	[w]() {
+		let e = super[w]();
+		return e.fieldNames = [...this.raw.fieldNames], e;
+	}
+	static baseline(e) {
+		return e == null ? e : { ...e };
+	}
+	addField(t, n) {
+		return O((r) => {
+			if (Object.hasOwn(this._fields, t)) throw Error(`Field ${t} is already in this form`);
+			this.takeChild(n, t), r.touch(this), e.setEntry(this._fields, t, n), r.whenRolledBack(() => e.dropEntry(this._fields, t)), this.state.fieldNames.push(t), this.completeRecords(n), this.bumpValueVersion(), this.notifyValueChanged();
+		}), this;
+	}
+	removeField(t) {
+		let n;
+		return O((r) => {
+			if (!Object.hasOwn(this._fields, t)) return;
+			let i = this._fields[t];
+			r.touch(this), this.releaseChild(i), e.dropEntry(this._fields, t), r.whenRolledBack(() => e.setEntry(this._fields, t, i)), this.state.fieldNames.splice(this.state.fieldNames.indexOf(t), 1), this.bumpValueVersion(), this.notifyValueChanged(), n = i;
+		}), n;
+	}
+	static setEntry(e, t, n) {
+		e[t] = n;
+	}
+	static dropEntry(e, t) {
+		delete e[t];
+	}
+	static isValidFields(e) {
+		function t(e) {
+			return e instanceof Y;
+		}
+		return typeof e == "object" && !!e && Object.entries(e).every(([, e]) => t(e));
+	}
+	static createFromFormData(t) {
+		if (t instanceof Y) throw Error("data is already a Form structure, should be a simple object");
+		return new e(t == null ? {} : Object.fromEntries(Object.entries(t).map(([e, t]) => [e, new Q({ value: t })])));
+	}
+	field(e) {
+		return this._fields[e] ?? null;
+	}
+	get fields() {
+		let e = lt.get(this);
+		return e || (e = new Proxy(this._fields, ut(() => this.state.fieldNames.length)), lt.set(this, e)), e;
+	}
+	get members() {
+		return this.raw.fieldNames.map((e) => this._fields[e]);
+	}
+	get value() {
+		let e = this.valueVersion;
+		if (this.raw.cachedValueVersion === e) return this.raw.cachedValue;
+		let t = Object.create(null);
+		Object.entries(this._fields).forEach(([e, n]) => {
+			let r = n.value;
+			(n.enabled || this.childComposesValue(n) && !h(r)) && (t[e] = r);
+		});
+		let n = h(t) ? null : Object.freeze({ ...t });
+		return this.raw.cachedValue = n, this.raw.cachedValueVersion = e, n;
+	}
+	assignMembers(e) {
+		O(() => {
+			Object.entries(this._fields).forEach(([t, n]) => {
+				(e == null || Object.hasOwn(e, t)) && (n.value = e == null ? null : e[t]);
+			});
+		});
+	}
+	set value(e) {
+		O((t) => {
+			this.assignMembers(e), t.markValidityDirty(this);
+		});
+	}
+	resetTo(t, n) {
+		let r = t;
+		O((t) => {
+			t.touch(this), this.errors.length && (this.errors = []), Object.entries(this._fields).forEach(([e, t]) => {
+				let i;
+				n === null ? i = null : n !== void 0 && Object.hasOwn(n, e) && (i = n[e]), this.resetChild(t, r.field(e) ?? t, i);
+			});
+			let i = this.value;
+			this.raw.announcedValue = i, this.originalValue = e.baseline(i), super.validate(!0);
+		});
+	}
+	get touched() {
+		return Object.values(this._fields).some((e) => e.touched);
+	}
+	set touched(e) {
+		O(() => {
+			Object.values(this._fields).forEach((t) => {
+				t.touched = e;
+			});
+		});
+	}
+	get fullValue() {
+		let e = Object.create(null);
+		return Object.entries(this._fields).forEach(([t, n]) => {
+			e[t] = n.fullValue;
+		}), { ...e };
+	}
+	notifyValueChanged() {
+		this.propagateValueChanged();
+	}
+	get composesValue() {
+		return !0;
+	}
+	refreshPreviousValue() {
+		this.raw.announcedValue = this.value;
+	}
+	get valid() {
+		return this.validRead;
+	}
+	composeValid() {
+		return this.state.errors.length === 0 && this.state.fieldNames.every((e) => this._fields[e].valid);
+	}
+	get busy() {
+		return this.busyRead;
+	}
+	composeBusy() {
+		return this.state.fieldNames.some((e) => this._fields[e].busy);
+	}
+	validate(e = !1) {
+		O(() => {
+			e && Object.values(this._fields).forEach((e) => e.validate(!0)), super.validate(e);
+		});
+	}
+	static assertTookFields(e, t, n) {
+		let r = Object.entries(t), i = e.raw.fieldNames;
+		if (!(r.length === i.length && r.every(([t, n]) => e._fields[t] === n))) throw TypeError(`${n}.bind() built an element that did not take the members it was given, so the binding would carry the declaration's data. A subclass whose constructor does not take (fields, params) has to override bind() and construct itself.`);
+	}
+	bind(t, n) {
+		let r = Object.create(null);
+		Object.entries(this._fields).forEach(([e, t]) => {
+			r[e] = t.bind();
+		});
+		let i = this.constructor, a = new i(r, {
+			value: t === void 0 ? this.value : t,
+			...n && "originalValue" in n ? { originalValue: n.originalValue } : {},
+			enabled: n?.enabled ?? this.enabled,
+			visibility: n?.visibility ?? this.visibility
+		});
+		return e.assertTookFields(a, r, this.constructor.name), a.boundFrom(this, a.raw.announcedValue, a.originalValue, n), a;
+	}
+	rebind(e) {
+		return super.rebind(e);
+	}
+}, dt = class e extends Y {
+	get [Symbol.toStringTag]() {
+		return "List";
+	}
+	get state() {
+		return super.state;
+	}
+	get raw() {
+		return super.raw;
+	}
+	_itemTemplate;
+	constructor(t, n) {
+		super(it()), this._itemTemplate = t, O(() => {
+			if (n) {
+				let { value: e, validators: t, actions: r, ...i } = n;
+				this.registerInitialActions([...t || [], ...r || []]), this.assignParams(i), e === void 0 ? this.originalValue !== void 0 && this.setValueInternal(this.originalValue) : this.setValueInternal(e);
+			}
+			this.constructed(n), this.originalValue === void 0 && (this.originalValue = e.baseline(this.value)), this.raw.announcedValue = this.value, this.boundActions?.triggerEager(this, this.value, this.originalValue), this.validate();
+		});
+	}
+	[w]() {
+		let e = super[w]();
+		return e.rows = this.raw.rows ? [...this.raw.rows] : this.raw.rows, e;
+	}
+	static baseline(e) {
+		return e == null ? e : [...e];
+	}
+	processSetValueItem(e) {
+		let t;
+		return t = e instanceof $ ? e : this._itemTemplate ? this._itemTemplate.bind(e) : $.createFromFormData(e), this.takeChild(t), this.completeRecords(t), t;
+	}
+	createPaddingItem() {
+		return this.processSetValueItem(this._itemTemplate ? this._itemTemplate.bind() : null);
+	}
+	rowsChanged() {
+		this.state.rowsVersion++;
+	}
+	static rowsDiffer(e, t) {
+		let n = e ?? [], r = t ?? [];
+		return n.length !== r.length || n.some((e, t) => e !== r[t]);
+	}
+	setValueInternal(t) {
+		if (t != null && !Array.isArray(t)) throw TypeError("Invalid value provided: a list takes an array of rows, or null to empty it");
+		O((n) => {
+			n.touch(this);
+			let r = this.raw.rows;
+			if (t == null) this.releaseRows(), this.state.rows = null;
+			else {
+				let e = this.state.rows ?? [], n = Array(t.length);
+				for (let r = 0; r < t.length; r++) {
+					let i = t[r], a = e[r];
+					a && this._itemTemplate && !(i instanceof $) ? (this.resetChild(a, this._itemTemplate, i), n[r] = a) : (a && this.releaseChild(a), n[r] = this.processSetValueItem(i));
+				}
+				for (let n = t.length; n < e.length; n++) this.releaseChild(e[n]);
+				this.state.rows = n;
+			}
+			e.rowsDiffer(r, this.raw.rows) && this.rowsChanged(), this.bumpValueVersion();
+		});
+	}
+	get value() {
+		let e = this.valueVersion;
+		if (this.raw.cachedValueVersion === e) return this.raw.cachedValue;
+		let t = this.state.rows?.map((e) => e.value), n = h(t) ? null : Object.freeze(t);
+		return this.raw.cachedValue = n, this.raw.cachedValueVersion = e, n;
+	}
+	set value(e) {
+		O(() => {
+			this.setValueInternal(e), this.propagateValueChanged(!0);
+		});
+	}
+	resetTo(t, n) {
+		O((r) => {
+			r.touch(this), this.errors.length && (this.errors = []), this.setValueInternal(n === void 0 ? t.value : n);
+			let i = this.value;
+			this.raw.announcedValue = i, this.originalValue = e.baseline(i), super.validate(!0);
+		});
+	}
+	get touched() {
+		return this.state.rows?.some((e) => e.touched) || !1;
+	}
+	set touched(e) {
+		O(() => {
+			this.state.rows?.forEach((t) => {
+				t.touched = e;
+			});
+		});
+	}
+	bind(e, t) {
+		let n = this._itemTemplate?.bind(), r = this.constructor, i = new r(n, {
+			value: [...(e === void 0 ? this.value : e) ?? []],
+			...t && "originalValue" in t ? { originalValue: t.originalValue } : {},
+			enabled: t?.enabled ?? this.enabled,
+			visibility: t?.visibility ?? this.visibility
+		});
+		if (i._itemTemplate !== n) throw TypeError(`${this.constructor.name}.bind() built a list that did not take the item template it was given, so the binding would carry the declaration's rows. A subclass whose constructor does not take (itemTemplate, params) has to override bind() and construct itself.`);
+		return i.boundFrom(this, i.value, i.originalValue, t), i;
+	}
+	notifyValueChanged() {
+		this.propagateValueChanged();
+	}
+	get composesValue() {
+		return !0;
+	}
+	refreshPreviousValue() {
+		this.raw.announcedValue = this.value;
+	}
+	get valid() {
+		return this.validRead;
+	}
+	composeValid() {
+		return this.state.errors.length === 0 && (this.state.rows?.every((e) => e.valid) ?? !0);
+	}
+	get busy() {
+		return this.busyRead;
+	}
+	composeBusy() {
+		return this.state.rows?.some((e) => e.busy) ?? !1;
+	}
+	validate(e = !1) {
+		O(() => {
+			e && this.state.rows?.forEach((e) => e.validate(!0)), super.validate(e);
+		});
+	}
+	get members() {
+		return this.raw.rows ?? [];
+	}
+	get fullValue() {
+		return (this.state.rows ?? []).map((e) => e.fullValue);
+	}
+	get length() {
+		return this.state.rows?.length ?? 0;
+	}
+	get items() {
+		let e = this.state.rowsVersion;
+		return this.raw.cachedItemsVersion !== e && (this.raw.cachedItems = Object.freeze([...this.raw.rows ?? []]), this.raw.cachedItemsVersion = e), this.raw.cachedItems;
+	}
+	get(e) {
+		return this.state.rows == null ? void 0 : this.state.rows[e];
+	}
+	push(e) {
+		return this.insert(e, this.state.rows?.length ?? 0) + 1;
+	}
+	pop() {
+		return this.remove((this.state.rows?.length ?? 0) - 1);
+	}
+	remove(e) {
+		let t;
+		return O((n) => {
+			if (this.state.rows == null || e < 0 || this.state.rows.length <= e) return;
+			n.touch(this);
+			let r = this.state.rows.splice(e, 1)?.[0];
+			r && (this.releaseChild(r), this.rowsChanged(), this.bumpValueVersion(), t = r, n.recordStructural(this, {
+				actionClass: Qe,
+				item: t,
+				index: e
+			}), this.propagateValueChanged(!0));
+		}), t;
+	}
+	insert(e, t) {
+		let n = 0;
+		return O((r) => {
+			for (r.touch(this), this.state.rows ?? (this.state.rows = []), n = t < 0 ? Math.max(this.state.rows.length + t, 0) : t; this.state.rows.length < n;) {
+				let e = this.createPaddingItem(), t = this.state.rows.push(e) - 1;
+				this.bumpValueVersion(), r.recordStructural(this, {
+					actionClass: Z,
+					item: e,
+					index: t
+				});
+			}
+			let i = this.processSetValueItem(e);
+			this.state.rows.splice(n, 0, i), r.recordStructural(this, {
+				actionClass: Z,
+				item: i,
+				index: n
+			}), this.rowsChanged(), this.bumpValueVersion(), this.propagateValueChanged(!0);
+		}), n;
+	}
+	releaseRows() {
+		this.state.rows?.forEach((e) => this.releaseChild(e));
+	}
+	clear() {
+		O((e) => {
+			let t = (this.state.rows?.length ?? 0) > 0;
+			e.touch(this), this.releaseRows(), this.state.rows = null, t && this.rowsChanged(), this.bumpValueVersion(), this.propagateValueChanged(t);
+		});
+	}
+}, ft = class extends I {
+	isValidComparison;
+	otherField;
+	registrations = /* @__PURE__ */ new WeakSet();
+	listening = /* @__PURE__ */ new WeakSet();
+	declarations = /* @__PURE__ */ new Set();
+	constructor(e, t, n) {
+		super((e, t, r) => {
+			this.comparisonState(r).oldValue = t;
+			let i = this.resolve(r);
+			return i ? (this.listenOn(i), this.isValidComparison(d(e), d(i.value)) ? null : [new N(this.replacePlaceholders(n, {
+				newValue: e,
+				oldValue: t,
+				field: r,
+				otherField: i
+			}), "", "compare-to")]) : (r.markRecordIncomplete(), null);
+		}), this.isValidComparison = t, this.otherField = e;
+	}
+	resolve(e) {
+		let t = this.otherField;
+		return typeof t == "function" ? t(e) ?? void 0 : typeof t == "string" ? Pe(t, e) : Me(t, R(e));
+	}
+	listenOn(e) {
+		this.listening.has(e) || this.listening.has(e.declaration) || (this.listening.add(e), e.registerAction(new C((e, t, n, r) => {
+			t(e, n, r);
+			let i = R(e);
+			this.declarations.forEach((e) => Ne(e, i).forEach((e) => {
+				this.registrations.has(e) && this.execute(e, () => null, e.value, this.comparisonState(e).oldValue);
+			}));
+		})));
+	}
+	boundToBinding(e) {
+		this.declarations.add(e.declaration), this.registrations.add(e);
+	}
+	comparisonState(e) {
+		return this.bindingState(e);
+	}
+	newBindingState() {
+		return {
+			...super.newBindingState(),
+			oldValue: void 0
+		};
+	}
+	unregisterFrom(e) {
+		super.unregisterFrom(e), this.registrations.delete(e);
+	}
+}, pt = class extends I {
+	constructor(e, t) {
+		let n = t || F("InAllowedValues"), r = () => {
+			let t = d(e);
+			return typeof t == "function" ? t() : t;
+		}, i = (e) => {
+			let t = e.join(", ");
+			return t.length <= 60 ? t : ne(t, {
+				length: 40,
+				separator: ", ",
+				omission: `... (${e.length} items total)`
+			});
+		};
+		super((e, t, a) => {
+			let o = r();
+			return o.includes(d(e)) ? null : [new N(this.replacePlaceholders(n, {
+				newValue: e,
+				oldValue: t,
+				field: a,
+				allowedValues: o,
+				allowedAsText: i(o)
+			}), "", "in-allowed-values")];
+		});
+	}
+};
+//#endregion
+//#region src/validators/validator-required.ts
+function mt(e) {
+	return e == null ? 0 : p(e) || _(e) ? e.length : te(e) && Object.getPrototypeOf(e) === Object.prototype ? Object.keys(e).length : String(e).length;
+}
+function ht(e) {
+	return typeof e == "object" && !!e && !o(e) && !(e instanceof String) && !("componentName" in e);
+}
+var gt = class extends I {
+	constructor(e, t) {
+		let n = ht(e) ? void 0 : e, r = (ht(e) ? e : t)?.trim ?? !0, i = n || F("Required");
+		super((e, t, n) => {
+			let a = d(e);
+			return mt(r && _(a) ? a.trim() : a) === 0 ? [new N(this.replacePlaceholders(i, {
+				newValue: e,
+				oldValue: t,
+				field: n
+			}), "", "required")] : null;
+		});
+	}
+}, _t = class extends I {
+	constructor(e, t) {
+		let n = t || F("MinValue");
+		super((t, r, i) => t < e || t === void 0 ? [new N(this.replacePlaceholders(n, {
+			newValue: t,
+			oldValue: r,
+			field: i,
+			minValue: e
+		}), "", "min")] : null);
+	}
+}, vt = class extends I {
+	constructor(e, t) {
+		let n = t || F("MaxValue");
+		super((t, r, i) => t > e || t === void 0 ? [new N(this.replacePlaceholders(n, {
+			newValue: t,
+			oldValue: r,
+			field: i,
+			maxValue: e
+		}), "", "max")] : null);
+	}
+}, yt = class extends I {
+	constructor(e, t, n) {
+		let r = n || F("ValueInRange");
+		super((n, i, a) => n < e || n > t || n === void 0 ? [new N(this.replacePlaceholders(r, {
+			newValue: n,
+			oldValue: i,
+			field: a,
+			minValue: e,
+			maxValue: t
+		}), "", "range")] : null);
+	}
+};
+//#endregion
+//#region src/validators/validator-min-max-range-length.ts
+function bt(e) {
+	return e == null ? 0 : p(e) || _(e) ? e.length : te(e) && Object.getPrototypeOf(e) === Object.prototype ? Object.keys(e).length : String(e).length;
+}
+var xt = class extends I {
+	constructor(e, t) {
+		let n = t || F("MinLength");
+		super((t, r, i) => bt(t) < e ? [new N(this.replacePlaceholders(n, {
+			newValue: t,
+			oldValue: r,
+			field: i,
+			minLength: e
+		}), "", "min-length")] : null);
+	}
+}, St = class extends I {
+	constructor(e, t) {
+		let n = t || F("MaxLength");
+		super((t, r, i) => bt(t) > e ? [new N(this.replacePlaceholders(n, {
+			newValue: t,
+			oldValue: r,
+			field: i,
+			maxLength: e
+		}), "", "max-length")] : null);
+	}
+}, Ct = class extends I {
+	constructor(e, t, n) {
+		let r = n || F("LengthInRange");
+		super((n, i, a) => {
+			let o = bt(n);
+			return o < e || o > t ? [new N(this.replacePlaceholders(r, {
+				newValue: n,
+				oldValue: i,
+				field: a,
+				minLength: e,
+				maxLength: t
+			}), "", "range-length")] : null;
+		});
+	}
+}, wt = class extends I {
+	constructor(e, t) {
+		let n = t || F("Pattern");
+		super((t, r, i) => e.test(String(d(t))) ? null : [new N(this.replacePlaceholders(n, {
+			newValue: t,
+			oldValue: r,
+			field: i,
+			pattern: e
+		}), "", "pattern")]);
+	}
+}, Tt = /* @__PURE__ */ ie({
+	CompareTo: () => ft,
+	InAllowedValues: () => pt,
+	LengthInRange: () => Ct,
+	MaxLength: () => St,
+	MaxValue: () => vt,
+	MinLength: () => xt,
+	MinValue: () => _t,
+	Pattern: () => wt,
+	Required: () => gt,
+	Validator: () => I,
+	ValueInRange: () => yt
+}), Et = /* @__PURE__ */ ie({
+	AbortEventHandlingException: () => S,
+	Action: () => st,
+	ActionsMap: () => L,
+	ConditionalEnabledAction: () => Le,
+	ConditionalStatementAction: () => z,
+	ConditionalValueAction: () => Re,
+	ConditionalVisibilityAction: () => Ie,
+	DisplayMode: () => b,
+	EnabledChangedAction: () => U,
+	EnabledChangingAction: () => H,
+	ExecuteAction: () => X,
+	Field: () => Q,
+	FieldActionBase: () => x,
+	FieldBase: () => Y,
+	Group: () => $,
+	List: () => dt,
+	ListItemAddedAction: () => Z,
+	ListItemRemovedAction: () => Qe,
+	MdString: () => k,
+	MessagesWidget: () => ct,
+	Operator: () => V,
+	RenderableValue: () => we,
+	Statement: () => Je,
+	ValidChangedAction: () => W,
+	ValidationError: () => M,
+	ValidationErrorRenderContent: () => N,
+	ValidationErrorText: () => Ce,
+	Validators: () => Tt,
+	ValueChangedAction: () => C,
+	VisibilityChangedAction: () => K,
+	VisibilityChangingAction: () => G,
+	buildErrorMessage: () => P,
+	defaultDisplayMode: () => 10,
+	isCallableFunction: () => j,
+	isSimpleComponentDef: () => A,
+	strings: () => Ee,
+	transaction: () => D,
+	translateStrings: () => De,
+	translatedMessage: () => F
+});
+//#endregion
+export { S as AbortEventHandlingException, st as Action, L as ActionsMap, Le as ConditionalEnabledAction, z as ConditionalStatementAction, Re as ConditionalValueAction, Ie as ConditionalVisibilityAction, b as DisplayMode, U as EnabledChangedAction, H as EnabledChangingAction, X as ExecuteAction, Q as Field, x as FieldActionBase, Y as FieldBase, $ as Group, dt as List, Z as ListItemAddedAction, Qe as ListItemRemovedAction, k as MdString, ct as MessagesWidget, V as Operator, we as RenderableValue, Je as Statement, W as ValidChangedAction, M as ValidationError, N as ValidationErrorRenderContent, Ce as ValidationErrorText, Tt as Validators, C as ValueChangedAction, K as VisibilityChangedAction, G as VisibilityChangingAction, P as buildErrorMessage, Et as default, ae as defaultDisplayMode, Se as forms, be as getConfig, j as isCallableFunction, A as isSimpleComponentDef, xe as setConfig, Ee as strings, D as transaction, De as translateStrings, F as translatedMessage };
+
+//# sourceMappingURL=dynamicforms-vue-forms.js.map