@dynamicforms/vue-forms 0.5.1 → 0.6.1

package/dist/dynamicforms-vue-forms.js

@@ -1,51 +1,51 @@
-var ft = Object.defineProperty, pt = Object.defineProperties;
-var bt = Object.getOwnPropertyDescriptors;
-var O = Object.getOwnPropertySymbols;
-var K = Object.prototype.hasOwnProperty, Z = Object.prototype.propertyIsEnumerable;
-var q = (i, s, t) => s in i ? ft(i, s, { enumerable: !0, configurable: !0, writable: !0, value: t }) : i[s] = t, _ = (i, s) => {
-  for (var t in s || (s = {}))
-    K.call(s, t) && q(i, t, s[t]);
-  if (O)
-    for (var t of O(s))
-      Z.call(s, t) && q(i, t, s[t]);
-  return i;
-}, R = (i, s) => pt(i, bt(s));
-var I = (i, s) => {
+var bt = Object.defineProperty, vt = Object.defineProperties;
+var yt = Object.getOwnPropertyDescriptors;
+var U = Object.getOwnPropertySymbols;
+var et = Object.prototype.hasOwnProperty, it = Object.prototype.propertyIsEnumerable;
+var q = (n, i, t) => i in n ? bt(n, i, { enumerable: !0, configurable: !0, writable: !0, value: t }) : n[i] = t, v = (n, i) => {
+  for (var t in i || (i = {}))
+    et.call(i, t) && q(n, t, i[t]);
+  if (U)
+    for (var t of U(i))
+      it.call(i, t) && q(n, t, i[t]);
+  return n;
+}, w = (n, i) => vt(n, yt(i));
+var F = (n, i) => {
   var t = {};
-  for (var e in i)
-    K.call(i, e) && s.indexOf(e) < 0 && (t[e] = i[e]);
-  if (i != null && O)
-    for (var e of O(i))
-      s.indexOf(e) < 0 && Z.call(i, e) && (t[e] = i[e]);
+  for (var e in n)
+    et.call(n, e) && i.indexOf(e) < 0 && (t[e] = n[e]);
+  if (n != null && U)
+    for (var e of U(n))
+      i.indexOf(e) < 0 && it.call(n, e) && (t[e] = n[e]);
   return t;
 };
-var l = (i, s, t) => q(i, typeof s != "symbol" ? s + "" : s, t);
-import { isEqual as k, isBoolean as vt, isString as C, isEmpty as H, truncate as mt, isArray as nt, isObject as it } from "lodash-es";
-import { unref as g, computed as G, reactive as yt, defineComponent as xt, resolveComponent as tt, openBlock as Et, createBlock as _t, h as S } from "vue";
-var w = /* @__PURE__ */ ((i) => (i[i.SUPPRESS = 1] = "SUPPRESS", i[i.HIDDEN = 5] = "HIDDEN", i[i.INVISIBLE = 8] = "INVISIBLE", i[i.FULL = 10] = "FULL", i))(w || {});
-const et = 10;
-((i) => {
-  function s(n) {
-    return n.toUpperCase() === "SUPPRESS" ? 1 : n.toUpperCase() === "HIDDEN" ? 5 : n.toUpperCase() === "INVISIBLE" ? 8 : et;
-  }
-  i.fromString = s;
-  function t(n) {
-    const r = typeof n == "number" ? n : i.fromString(n);
-    return Object.values(i).includes(r) ? r : et;
-  }
-  i.fromAny = t;
-  function e(n) {
-    const r = typeof n == "number" ? n : i.fromString(n);
-    return Object.values(i).includes(r);
-  }
-  i.isDefined = e;
-})(w || (w = {}));
-Object.freeze(w);
-const V = w;
-class b {
-  constructor(s) {
-    l(this, "executorFn");
-    this.executorFn = s;
+var o = (n, i, t) => q(n, typeof i != "symbol" ? i + "" : i, t);
+import { isEqual as D, isBoolean as Vt, isString as A, isEmpty as Q, truncate as Ct, isArray as rt, isObject as at } from "lodash-es";
+import { unref as h, computed as xt, isRef as _t, reactive as Et, defineComponent as It, resolveComponent as st, openBlock as At, createBlock as St, h as j } from "vue";
+var T = /* @__PURE__ */ ((n) => (n[n.SUPPRESS = 1] = "SUPPRESS", n[n.HIDDEN = 5] = "HIDDEN", n[n.INVISIBLE = 8] = "INVISIBLE", n[n.FULL = 10] = "FULL", n))(T || {});
+const nt = 10;
+((n) => {
+  function i(s) {
+    return s.toUpperCase() === "SUPPRESS" ? 1 : s.toUpperCase() === "HIDDEN" ? 5 : s.toUpperCase() === "INVISIBLE" ? 8 : nt;
+  }
+  n.fromString = i;
+  function t(s) {
+    const r = typeof s == "number" ? s : n.fromString(s);
+    return Object.values(n).includes(r) ? r : nt;
+  }
+  n.fromAny = t;
+  function e(s) {
+    const r = typeof s == "number" ? s : n.fromString(s);
+    return Object.values(n).includes(r);
+  }
+  n.isDefined = e;
+})(T || (T = {}));
+Object.freeze(T);
+const S = T;
+class m {
+  constructor(i) {
+    o(this, "executorFn");
+    this.executorFn = i;
   }
   static get classIdentifier() {
     throw new Error("classIdentifier must be declared");
@@ -53,48 +53,60 @@ class b {
   get classIdentifier() {
     return this.constructor.classIdentifier;
   }
-  execute(s, t, ...e) {
-    return this.executorFn(s, t, ...e);
+  execute(i, t, ...e) {
+    return this.executorFn(i, t, ...e);
   }
   get eager() {
     return !1;
   }
   // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  boundToField(s) {
+  boundToField(i) {
   }
   unregister() {
   }
 }
-class Q extends Error {
+class W extends Error {
 }
-const rt = /* @__PURE__ */ Symbol("ValueChangedAction");
-class v extends b {
-  constructor(s) {
-    super(s);
+const lt = /* @__PURE__ */ Symbol("ValueChangedAction");
+class y extends m {
+  constructor(i) {
+    super(i);
   }
   static get classIdentifier() {
-    return rt;
+    return lt;
   }
-  execute(s, t, e, n) {
-    return super.execute(s, t, e, n);
+  execute(i, t, e, s) {
+    return super.execute(i, t, e, s);
   }
 }
-class N extends String {
-  constructor(t, e, n) {
+const ot = { useMarkdownInValidators: !0 };
+function Pt() {
+  return ot;
+}
+function wt(n) {
+  Object.assign(ot, n);
+}
+const he = {
+  install(n, i) {
+    i && wt(i);
+  }
+};
+class O extends String {
+  constructor(t, e, s) {
     super(t);
-    l(this, "plugins");
-    l(this, "options");
-    this.plugins = n, this.options = e;
+    o(this, "plugins");
+    o(this, "options");
+    this.plugins = s, this.options = e;
   }
 }
-function W(i) {
-  const s = g(i);
-  return typeof s == "object" && "componentName" in s;
+function X(n) {
+  const i = h(n);
+  return typeof i == "object" && "componentName" in i;
 }
-function U(i) {
-  return typeof g(i) == "function";
+function k(n) {
+  return typeof h(n) == "function";
 }
-class X {
+class G {
   get componentName() {
     return "Comment";
   }
@@ -108,11 +120,11 @@ class X {
     return "";
   }
 }
-class Ct extends X {
+class Ft extends G {
   constructor(t, e = "") {
     super();
-    l(this, "text");
-    l(this, "classes");
+    o(this, "text");
+    o(this, "classes");
     this.text = t, this.classes = e;
   }
   get componentName() {
@@ -125,24 +137,24 @@ class Ct extends X {
     return this.classes;
   }
 }
-class p extends X {
+class g extends G {
   constructor(t, e = "") {
     super();
-    l(this, "classes");
-    l(this, "text");
-    l(this, "textType");
-    this.classes = e, this.text = t, this.textType = G(() => this.getTextType);
+    o(this, "classes");
+    o(this, "text");
+    o(this, "textType");
+    this.classes = e, this.text = t, this.textType = xt(() => this.getTextType);
   }
   get resolvedText() {
-    const t = g(this.text);
-    return U(t) ? t() : t;
+    const t = h(this.text);
+    return k(t) ? t() : t;
   }
   get getTextType() {
     const t = this.resolvedText;
-    return t ? t instanceof N ? "md" : W(t) ? "component" : "string" : "string";
+    return t ? t instanceof O ? "md" : X(t) ? "component" : "string" : "string";
   }
   get componentName() {
-    switch (g(this.textType)) {
+    switch (h(this.textType)) {
       case "string":
         return "template";
       case "md":
@@ -154,7 +166,7 @@ class p extends X {
     }
   }
   get componentBindings() {
-    switch (g(this.textType)) {
+    switch (h(this.textType)) {
       case "string":
         return {};
       case "md": {
@@ -168,7 +180,7 @@ class p extends X {
     }
   }
   get componentBody() {
-    switch (g(this.textType)) {
+    switch (h(this.textType)) {
       case "string":
         return this.resolvedText;
       case "component":
@@ -181,128 +193,163 @@ class p extends X {
     return this.classes;
   }
 }
-class Vt extends p {
+class jt extends g {
+}
+function b(n) {
+  return Pt().useMarkdownInValidators ? new O(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 At = /* @__PURE__ */ Symbol("Validator");
-class f extends v {
+const Nt = /* @__PURE__ */ Symbol("Validator"), Tt = () => b("Validation could not be completed");
+class f extends y {
   /**
    * Creates a new validator
    * @param validationFn Function that validates the field value and returns errors or null
    */
   constructor(t) {
-    super((n, r, a, o) => {
-      const c = t(a, o, n) || [], u = (h) => {
-        var A;
-        h == null || h.forEach(
-          (x) => Object.defineProperty(x, "source", { value: this.source, enumerable: !1, configurable: !1 })
-        );
-        for (let x = n.errors.length - 1; x >= 0; x--) {
-          const j = n.errors[x];
-          if (j.source === this.source) {
-            const P = (A = h == null ? void 0 : h.findIndex(($) => k($, j))) != null ? A : -1;
-            P >= 0 ? h == null || h.splice(P, 1) : n.errors.splice(x, 1);
+    super((s, r, a, l) => {
+      var B;
+      const u = ((B = this.runs.get(s)) != null ? B : 0) + 1;
+      this.runs.set(s, u);
+      const d = s.validationEpoch, x = () => this.runs.get(s) === u && s.validationEpoch === d, _ = t(a, l, s) || [], P = (p) => {
+        var K;
+        const E = (K = p == null ? void 0 : p.map((I) => this.claim(I))) != null ? K : [];
+        for (let I = s.errors.length - 1; I >= 0; I--) {
+          const Z = s.errors[I];
+          if (Z.source === this.source) {
+            const tt = E.findIndex((mt) => D(mt, Z));
+            tt >= 0 ? E.splice(tt, 1) : s.errors.splice(I, 1);
           }
         }
-        h && h.length > 0 && n.errors.push(...h), n.validate();
+        E.length > 0 && s.errors.push(...E), s.validate();
       };
-      return c instanceof Promise ? (n.validating = ++n.validatingCount > 0, c.then((h) => u(h)).finally(() => {
-        n.validatingCount = Math.max(0, n.validatingCount - 1), n.validating = n.validatingCount > 0;
-      })) : u(c), r(n, a, o);
+      return _ instanceof Promise ? (s.beginValidating(), _.then(
+        (p) => {
+          x() && P(p);
+        },
+        (p) => {
+          x() && (P([new g(Tt())]), console.error("Validation failed", p));
+        }
+      ).finally(() => s.endValidating()).catch((p) => console.error("Validation failed", p))) : P(_), r(s, a, l);
     });
-    l(this, "source");
+    o(this, "source");
+    /**
+     * Sequence number of the newest run of this validator, per field. Every execution takes the next number, and a
+     * result is applied only while its number is still the newest one, so a slow run cannot overwrite the verdict of
+     * a faster one that started after it. The key is the field because one validator instance may be registered on
+     * several fields, each with a sequence of its own.
+     */
+    o(this, "runs", /* @__PURE__ */ new WeakMap());
     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 r = Object.getOwnPropertyDescriptors(t);
+    return Object.create(Object.getPrototypeOf(t), w(v({}, r), { source: s }));
+  }
   static get classIdentifier() {
-    return At;
+    return Nt;
   }
   get eager() {
     return !0;
   }
   replacePlaceholdersFunction(t, e) {
     return () => {
-      let n = g(t);
-      for (; U(n); )
-        n = g(this.replacePlaceholders(n(), e));
-      return n;
+      let s = h(t);
+      for (; k(s); )
+        s = h(this.replacePlaceholders(s(), e));
+      return s;
     };
   }
   replacePlaceholders(t, e) {
-    if (U(t)) return this.replacePlaceholdersFunction(t, e);
-    if (W(t)) return t;
-    let n = g(t);
+    if (k(t)) return this.replacePlaceholdersFunction(t, e);
+    if (X(t)) return t;
+    if (_t(t))
+      return this.replacePlaceholdersFunction(() => h(t), e);
+    let s = h(t);
     return Object.keys(e).forEach((r) => {
-      n = n.replaceAll(`{${r}}`, e[r]);
-    }), t instanceof N ? new N(n.toString(), t.options, t.plugins) : n;
+      s = s.replaceAll(`{${r}}`, e[r]);
+    }), t instanceof O ? new O(s.toString(), t.options, t.plugins) : s;
   }
 }
-class T extends Map {
+class L extends Map {
   constructor() {
     super(...arguments);
-    l(this, "eagerActions", /* @__PURE__ */ new Set());
-    l(this, "registeredActions", []);
+    o(this, "eagerActions", /* @__PURE__ */ new Set());
+    o(this, "registeredActions", []);
   }
   register(t) {
-    if (!(t instanceof b)) throw new Error("Invalid action type");
+    if (!(t instanceof m)) throw new Error("Invalid action type");
     this.registeredActions.push(t);
-    const e = t.classIdentifier, n = this.get(e) || (() => null);
-    function r(a, ...o) {
-      return t.execute(a, n, ...o);
+    const e = t.classIdentifier, s = this.get(e) || (() => null);
+    function r(a, ...l) {
+      return t.execute(a, s, ...l);
     }
     this.set(e, r), t.eager && this.eagerActions.add(t.classIdentifier);
   }
-  trigger(t, e, ...n) {
+  trigger(t, e, ...s) {
     const r = t.classIdentifier;
-    r === rt && this.triggerEager(e, ...n);
+    r === lt && this.triggerEager(e, ...s);
     const a = this.get(r);
     try {
-      if (a) return a(e, ...n);
-    } catch (o) {
-      if (!(o instanceof Q)) throw o;
+      if (a) return a(e, ...s);
+    } catch (l) {
+      if (!(l instanceof W)) throw l;
     }
     return null;
   }
   triggerEager(t, ...e) {
-    for (const n of this.eagerActions) {
-      const r = this.get(n);
+    for (const s of this.eagerActions) {
+      const r = this.get(s);
       try {
         r && r(t, ...e);
       } catch (a) {
-        if (!(a instanceof Q)) throw a;
+        if (!(a instanceof W)) throw a;
       }
     }
   }
   clone() {
-    const t = new T();
+    const t = new L();
     return this.registeredActions.forEach((e) => t.register(e)), t;
   }
   cloneWithoutValidators() {
-    const t = new T();
+    const t = new L();
     return this.registeredActions.forEach((e) => {
       e instanceof f ? e.unregister() : t.register(e);
     }), t;
   }
 }
-const It = /* @__PURE__ */ Symbol("ConditionalStatementAction");
-class B extends v {
+const Ot = /* @__PURE__ */ Symbol("ConditionalStatementAction");
+class M extends y {
   constructor(t, e) {
-    const n = (r, a, o, c) => {
-      const u = t.evaluate();
-      if (u !== this.lastResult) {
-        for (const h of this.boundFields)
-          e(h, u, this.lastResult);
-        this.lastResult = u;
+    const s = (r, a, l, u) => {
+      const d = t.evaluate();
+      if (d !== this.lastResult) {
+        for (const x of this.boundFields)
+          e(x, d, this.lastResult);
+        this.lastResult = d;
       }
-      return a(r, o, c);
+      return a(r, l, u);
     };
-    super(n);
-    l(this, "lastResult");
+    super(s);
+    o(this, "lastResult");
     // boundField tracks the fields this action is bound to. so that it may perform the executorFn on them and not on the
     // ValueChangedAction fields that will call the actionExecutor
-    l(this, "boundFields", /* @__PURE__ */ new Set());
-    t.collectFields().forEach((r) => r.registerAction(new v(n)));
+    o(this, "boundFields", /* @__PURE__ */ new Set());
+    t.collectFields().forEach((r) => r.registerAction(new y(s)));
   }
   static get classIdentifier() {
-    return It;
+    return Ot;
   }
   get eager() {
     return !0;
@@ -311,30 +358,30 @@ class B extends v {
     this.boundFields.add(t);
   }
 }
-class St extends B {
-  constructor(s) {
-    super(s, (t, e) => {
-      t.visibility = e ? V.FULL : V.SUPPRESS;
+class Lt extends M {
+  constructor(i) {
+    super(i, (t, e) => {
+      t.visibility = e ? S.FULL : S.SUPPRESS;
     });
   }
 }
-class Ft extends B {
-  constructor(s) {
-    super(s, (t, e) => {
+class Rt extends M {
+  constructor(i) {
+    super(i, (t, e) => {
       t.enabled = e;
     });
   }
 }
-class wt extends B {
-  constructor(s, t) {
-    super(s, (e, n) => {
-      n && (e.value = t);
+class Bt extends M {
+  constructor(i, t) {
+    super(i, (e, s) => {
+      s && (e.value = t);
     });
   }
 }
-var L = /* @__PURE__ */ ((i) => (i[i.NOT = 0] = "NOT", i[i.OR = 1] = "OR", i[i.AND = 2] = "AND", i[i.XOR = 3] = "XOR", i[i.NAND = 4] = "NAND", i[i.NOR = 5] = "NOR", i[i.EQUALS = -1] = "EQUALS", i[i.NOT_EQUALS = -2] = "NOT_EQUALS", i[i.GT = -3] = "GT", i[i.LT = -4] = "LT", i[i.GE = -5] = "GE", i[i.LE = -6] = "LE", i[i.IN = -7] = "IN", i[i.NOT_IN = -8] = "NOT_IN", i[i.INCLUDES = -9] = "INCLUDES", i[i.NOT_INCLUDES = -10] = "NOT_INCLUDES", i))(L || {});
-((i) => {
-  function s(r) {
+var R = /* @__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))(R || {});
+((n) => {
+  function i(r) {
     const a = r.toLowerCase();
     if (a === "not") return 0;
     if (a === "or") return 1;
@@ -354,119 +401,160 @@ var L = /* @__PURE__ */ ((i) => (i[i.NOT = 0] = "NOT", i[i.OR = 1] = "OR", i[i.A
     if (["not_includes", "not-includes", "not includes"].includes(a)) return -10;
     throw new Error(`Unrecognised operator ${a}`);
   }
-  i.fromString = s;
+  n.fromString = i;
   function t(r) {
-    const a = typeof r == "number" ? r : i.fromString(r);
-    if (Object.values(i).includes(a)) return a;
+    const a = typeof r == "number" ? r : n.fromString(r);
+    if (Object.values(n).includes(a)) return a;
     throw new Error(`Unrecognised operator ${r}`);
   }
-  i.fromAny = t;
+  n.fromAny = t;
   function e(r) {
-    const a = typeof r == "number" ? r : i.fromString(r);
-    return Object.values(i).includes(a);
+    const a = typeof r == "number" ? r : n.fromString(r);
+    return Object.values(n).includes(a);
   }
-  i.isDefined = e;
-  function n(r) {
+  n.isDefined = e;
+  function s(r) {
     return r >= 0;
   }
-  i.isLogicOperator = n;
-})(L || (L = {}));
-Object.freeze(L);
-const d = L, Nt = /* @__PURE__ */ Symbol("EnabledChangingAction");
-class at extends b {
-  constructor(s) {
-    super(s);
+  n.isLogicOperator = s;
+})(R || (R = {}));
+Object.freeze(R);
+const c = R, Ut = /* @__PURE__ */ Symbol("EnabledChangingAction");
+class ut extends m {
+  constructor(i) {
+    super(i);
   }
   static get classIdentifier() {
-    return Nt;
+    return Ut;
   }
-  execute(s, t, e, n) {
-    return super.execute(s, t, e, n);
+  execute(i, t, e, s) {
+    return super.execute(i, t, e, s);
   }
 }
-const Tt = /* @__PURE__ */ Symbol("EnabledChangedAction");
-class ot extends b {
-  constructor(s) {
-    super(s);
+const kt = /* @__PURE__ */ Symbol("EnabledChangedAction");
+class ct extends m {
+  constructor(i) {
+    super(i);
   }
   static get classIdentifier() {
-    return Tt;
+    return kt;
   }
-  execute(s, t, e, n) {
-    return super.execute(s, t, e, n);
+  execute(i, t, e, s) {
+    return super.execute(i, t, e, s);
   }
 }
-const Lt = /* @__PURE__ */ Symbol("ValidChangedAction");
-class lt extends b {
-  constructor(s) {
-    super(s);
+const Dt = /* @__PURE__ */ Symbol("ValidChangedAction");
+class ht extends m {
+  constructor(i) {
+    super(i);
   }
   static get classIdentifier() {
-    return Lt;
+    return Dt;
   }
-  execute(s, t, e, n) {
-    return super.execute(s, t, e, n);
+  execute(i, t, e, s) {
+    return super.execute(i, t, e, s);
   }
 }
-const jt = /* @__PURE__ */ Symbol("VisibilityChangingAction");
-class ct extends b {
-  constructor(s) {
-    super(s);
+const Mt = /* @__PURE__ */ Symbol("VisibilityChangingAction");
+class dt extends m {
+  constructor(i) {
+    super(i);
   }
   static get classIdentifier() {
-    return jt;
+    return Mt;
   }
-  execute(s, t, e, n) {
-    return super.execute(s, t, e, n);
+  execute(i, t, e, s) {
+    return super.execute(i, t, e, s);
   }
 }
-const Pt = /* @__PURE__ */ Symbol("VisibilityChangedAction");
-class ut extends b {
-  constructor(s) {
-    super(s);
+const $t = /* @__PURE__ */ Symbol("VisibilityChangedAction");
+class gt extends m {
+  constructor(i) {
+    super(i);
   }
   static get classIdentifier() {
-    return Pt;
+    return $t;
   }
-  execute(s, t, e, n) {
-    return super.execute(s, t, e, n);
+  execute(i, t, e, s) {
+    return super.execute(i, t, e, s);
   }
 }
-class y {
+class V {
+  /**
+   * A field is a Vue reactive proxy from construction onwards: the base constructor returns the proxy, and a
+   * derived class's `this` is whatever super() returned, so every subclass constructor, field initializer and
+   * method sees the proxy. Consequence: plain `field.property = value` is tracked, with no wrapper in between.
+   */
   constructor() {
-    l(this, "reactiveValue", G(() => this.value));
     // contains original field value as was provided at creation
-    l(this, "validatingCount", 0);
-    l(this, "validating", !1);
-    l(this, "_valid", !0);
+    o(this, "validatingCount", 0);
+    o(this, "_valid", !0);
     // is current value valid as per FE and BE validators?
-    l(this, "errors", []);
+    o(this, "errors", []);
     // when member of a Group, fieldName specifies the name of this field
-    l(this, "actions", new T());
+    o(this, "actions", new L());
     // default property handlers
-    l(this, "_visibility", V.FULL);
-    l(this, "_enabled", !0);
+    o(this, "_visibility", S.FULL);
+    o(this, "_enabled", !0);
+    /**
+     * While true, validate() on this field does nothing at all: it neither recomputes _valid nor emits
+     * ValidChangedAction, and nothing climbs to the parent. A container that walks its members one by one - assigning
+     * them a value, or revalidating them - sets it for the duration of the walk, so a member's upward climb cannot
+     * announce the verdict of a half-applied value or of a half-revalidated set, and clears it in a finally block
+     * followed by its own validate(). That call recomputes over the finished state and emits the net transition, so
+     * the deferral cannot swallow a real change.
+     */
+    o(this, "suppressValidation", !1);
+    /**
+     * While true, a validity change is still recomputed and still announced on this field, but it is not passed up to
+     * the parent: the climb is only remembered and carried out by flushParentValidityClimb(). A setter that notifies
+     * the parent of the new value itself holds it over the notifying region, so the parent forms its verdict once,
+     * over the finished value, instead of once over the value being replaced and once over the value replacing it.
+     */
+    o(this, "suppressParentValidityClimb", !1);
+    o(this, "parentValidityClimbPending", !1);
+    o(this, "_validationEpoch", 0);
+    return Et(this);
+  }
+  /** true while at least one asynchronous validator is still running for this field */
+  get validating() {
+    return this.validatingCount > 0;
+  }
+  /** announces the start of one asynchronous validation run; validators pair it with endValidating */
+  beginValidating() {
+    this.validatingCount++;
+  }
+  /** announces the end of one asynchronous validation run */
+  endValidating() {
+    this.validatingCount = Math.max(0, this.validatingCount - 1);
   }
   get visibility() {
     return this._visibility;
   }
-  set visibility(s) {
-    const t = this._visibility, e = this.actions.trigger(ct, this, s, t);
-    if (!V.isDefined(e != null ? e : s)) throw new Error("visibility must be a DisplayMode constant");
-    this._visibility = V.fromAny(e != null ? e : s), this.actions.trigger(ut, this, this._visibility, t);
+  set visibility(i) {
+    const t = this._visibility, e = this.actions.trigger(dt, this, i, t);
+    if (!S.isDefined(e != null ? e : i)) throw new Error("visibility must be a DisplayMode constant");
+    this._visibility = S.fromAny(e != null ? e : i), this.actions.trigger(gt, this, this._visibility, t);
   }
   get enabled() {
     return this._enabled;
   }
-  set enabled(s) {
-    const t = this._enabled, e = this.actions.trigger(at, this, s, t);
-    if (!vt(e != null ? e : s)) throw new Error("Enabled value must be boolean");
-    this._enabled = e != null ? e : s, this.actions.trigger(ot, this, this._enabled, t);
+  set enabled(i) {
+    const t = this._enabled, e = this.actions.trigger(ut, this, i, t);
+    if (!Vt(e != null ? e : i)) throw new Error("Enabled value must be boolean");
+    this._enabled = e != null ? e : i, this.actions.trigger(ct, this, this._enabled, t);
   }
-  validate(s = !1) {
-    s && this.actions.triggerEager(this, this.value, this.value);
+  /** Carries out the climb that a validity change made while suppressParentValidityClimb was held, if there was one. */
+  flushParentValidityClimb() {
+    var i;
+    this.parentValidityClimbPending && (this.parentValidityClimbPending = !1, (i = this.parent) == null || i.validate());
+  }
+  validate(i = !1) {
+    var e;
+    if (this.suppressValidation) return;
+    i && this.actions.triggerEager(this, this.value, this.value);
     const t = this._valid;
-    this._valid = this.valid, this._valid !== t && this.actions.trigger(lt, this, this.valid, t);
+    this._valid = this.valid, this._valid !== t && (this.actions.trigger(ht, this, this.valid, t), this.suppressParentValidityClimb ? this.parentValidityClimbPending = !0 : (e = this.parent) == null || e.validate());
   }
   get valid() {
     return this.errors.length === 0;
@@ -475,73 +563,94 @@ class y {
     return this.value;
   }
   get isChanged() {
-    return !k(this.value, this.originalValue);
+    return !D(this.value, this.originalValue);
+  }
+  /**
+   * 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(i) {
+    i.forEach((t) => {
+      this.actions.register(t), t.boundToField(this);
+    });
   }
-  registerAction(s) {
-    const t = s;
-    return this.actions.register(t), t.boundToField(this), t.eager && this.actions.trigger(Object.getPrototypeOf(s).constructor, this, this.value, this.originalValue), this;
+  registerAction(i) {
+    return this.actions.register(i), i.boundToField(this), i.eager && this.actions.trigger(Object.getPrototypeOf(i).constructor, this, this.value, this.originalValue), this;
   }
-  triggerAction(s, ...t) {
-    return this.actions.trigger(s, this, ...t);
+  triggerAction(i, ...t) {
+    return this.actions.trigger(i, this, ...t);
+  }
+  /**
+   * 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._validationEpoch;
   }
   clearValidators() {
-    this.actions = this.actions.cloneWithoutValidators(), this.errors = [], this._valid = !0;
+    this._validationEpoch++, this.actions = this.actions.cloneWithoutValidators(), this.errors = [], this.validate();
   }
 }
-function Ot(i, s) {
-  return i ? !s : s;
+function qt(n, i) {
+  return n ? !i : i;
 }
-class F {
-  constructor(s, t, e) {
-    l(this, "operand1");
-    l(this, "operator");
-    l(this, "operand2");
-    this.operand1 = s, this.operator = t, this.operand2 = e;
+class N {
+  constructor(i, t, e) {
+    o(this, "operand1");
+    o(this, "operator");
+    o(this, "operand2");
+    this.operand1 = i, this.operator = t, this.operand2 = e;
   }
   get operand1Value() {
-    return this.operand1 instanceof F ? this.operand1.evaluate() : this.operand1 instanceof y ? g(this.operand1.value) : this.operand1;
+    return this.operand1 instanceof N ? this.operand1.evaluate() : this.operand1 instanceof V ? h(this.operand1.value) : this.operand1;
   }
   get operand2Value() {
-    return this.operand2 instanceof F ? this.operand2.evaluate() : this.operand2 instanceof y ? g(this.operand2.value) : this.operand2;
+    return this.operand2 instanceof N ? this.operand2.evaluate() : this.operand2 instanceof V ? h(this.operand2.value) : this.operand2;
   }
   evaluate() {
-    var e, n, r, a;
-    const s = this.operand1Value, t = this.operand2Value;
+    var e, s;
+    const i = this.operand1Value, t = this.operand2Value;
     switch (this.operator) {
       // logical operators
-      case d.AND:
-        return s && t;
-      case d.OR:
-        return s || t;
-      case d.NAND:
-        return !(s && t);
-      case d.NOR:
-        return !(s || t);
-      case d.XOR:
-        return Ot(s, t);
-      case d.NOT:
-        return !s;
+      // `&&` 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 !!(i && t);
+      case c.OR:
+        return !!(i || t);
+      case c.NAND:
+        return !(i && t);
+      case c.NOR:
+        return !(i || t);
+      case c.XOR:
+        return qt(!!i, !!t);
+      case c.NOT:
+        return !i;
       // comparison operators
-      case d.EQUALS:
-        return s == t;
-      case d.NOT_EQUALS:
-        return s != t;
-      case d.LT:
-        return s < t;
-      case d.LE:
-        return s <= t;
-      case d.GE:
-        return s >= t;
-      case d.GT:
-        return s > t;
-      case d.IN:
-        return (n = (e = t == null ? void 0 : t.includes) == null ? void 0 : e.call(t, s)) != null ? n : !1;
-      case d.NOT_IN:
-        return !((a = (r = t == null ? void 0 : t.includes) == null ? void 0 : r.call(t, s)) == null || a);
-      case d.INCLUDES:
-        return C(s) && C(t) && s.indexOf(t) >= 0;
-      case d.NOT_INCLUDES:
-        return !(C(s) && C(t) && s.indexOf(t) >= 0);
+      case c.EQUALS:
+        return i == t;
+      case c.NOT_EQUALS:
+        return i != t;
+      case c.LT:
+        return i < t;
+      case c.LE:
+        return i <= t;
+      case c.GE:
+        return i >= t;
+      case c.GT:
+        return i > t;
+      case c.IN:
+        return !!((e = t == null ? void 0 : t.includes) != null && e.call(t, i));
+      case c.NOT_IN:
+        return !((s = t == null ? void 0 : t.includes) != null && s.call(t, i));
+      case c.INCLUDES:
+        return A(i) && A(t) && i.indexOf(t) >= 0;
+      case c.NOT_INCLUDES:
+        return !(A(i) && A(t) && i.indexOf(t) >= 0);
       default:
         throw new Error(`Operator not implemented ${this.operator}`);
     }
@@ -551,82 +660,86 @@ class F {
    * @returns A set of all fields used in this statement
    */
   collectFields() {
-    const s = /* @__PURE__ */ new Set();
+    const i = /* @__PURE__ */ new Set();
     function t(e) {
-      e instanceof y ? s.add(e) : e instanceof F && e.collectFields().forEach((r) => s.add(r));
+      e instanceof V ? i.add(e) : e instanceof N && e.collectFields().forEach((r) => i.add(r));
     }
-    return t(this.operand1), t(this.operand2), s;
+    return t(this.operand1), t(this.operand2), i;
   }
 }
-const Rt = /* @__PURE__ */ Symbol("ExecuteAction");
-class ht extends b {
-  constructor(s) {
-    super(s);
+const Ht = /* @__PURE__ */ Symbol("ExecuteAction");
+class ft extends m {
+  constructor(i) {
+    super(i);
   }
   static get classIdentifier() {
-    return Rt;
+    return Ht;
   }
-  execute(s, t, e) {
-    return super.execute(s, t, e);
+  execute(i, t, e) {
+    return super.execute(i, t, e);
   }
 }
-const Ut = /* @__PURE__ */ Symbol("ListItemAddedAction");
-class z extends b {
-  constructor(s) {
-    super(s);
+const Qt = /* @__PURE__ */ Symbol("ListItemAddedAction");
+class z extends m {
+  constructor(i) {
+    super(i);
   }
   static get classIdentifier() {
-    return Ut;
+    return Qt;
   }
-  execute(s, t, e, n) {
-    return super.execute(s, t, e, n);
+  execute(i, t, e, s) {
+    return super.execute(i, t, e, s);
   }
 }
-const kt = /* @__PURE__ */ Symbol("ListItemRemovedAction");
-class dt extends b {
-  constructor(s) {
-    super(s);
+const Wt = /* @__PURE__ */ Symbol("ListItemRemovedAction");
+class pt extends m {
+  constructor(i) {
+    super(i);
   }
   static get classIdentifier() {
-    return kt;
+    return Wt;
   }
-  execute(s, t, e, n) {
-    return super.execute(s, t, e, n);
+  execute(i, t, e, s) {
+    return super.execute(i, t, e, s);
   }
 }
-const st = /* @__PURE__ */ Symbol("FieldConstructorGuard");
-class D extends y {
+class $ extends V {
   constructor(t) {
     super();
-    l(this, "_value");
-    l(this, "_touched", !1);
-    if (t !== st) {
-      const e = this.constructor.name;
-      throw new TypeError(`Don't use constructor to instantiate ${e}. Use ${e}.create<T>`);
-    }
+    o(this, "_value");
+    o(this, "_touched", !1);
+    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) {
     if (t) {
-      const e = t, { value: n, validators: r, actions: a } = e, o = I(e, ["value", "validators", "actions"]);
-      [...r || [], ...a || []].forEach((c) => this.registerAction(c)), Object.assign(this, o), this._value = n != null ? n : this.originalValue, this.originalValue === void 0 && (this.originalValue = this._value);
+      const e = t, { value: s, validators: r, actions: a } = e, l = F(e, ["value", "validators", "actions"]);
+      this.registerInitialActions([...r || [], ...a || []]), Object.assign(this, l), this._value = s !== void 0 ? s : this.originalValue, this.originalValue === void 0 && (this.originalValue = this._value);
     }
     this.actions.triggerEager(this, this.value, this.originalValue), this.validate();
   }
-  /**
-   * Creates a new reactive Field instance.
-   * @param params Initial field parameters
-   * @returns Reactive Field instance
-   */
-  static create(t) {
-    const e = yt(new this(st));
-    return e.init(t), e;
-  }
   get value() {
     return this._value;
   }
   set value(t) {
     const e = this._value;
-    !this.enabled || e === t || (this._value = t, this.actions.trigger(v, this, this._value, e), this.parent && this.parent.notifyValueChanged(), this.validate());
+    if (!this.enabled || e === t) return;
+    this._value = t;
+    const s = this.suppressParentValidityClimb;
+    this.suppressParentValidityClimb = !0;
+    try {
+      this.actions.trigger(y, this, this._value, e), this.parent && this.parent.notifyValueChanged();
+    } finally {
+      this.suppressParentValidityClimb = s, this.validate(), this.flushParentValidityClimb();
+    }
   }
   get touched() {
     return this._touched;
@@ -635,64 +748,59 @@ class D extends y {
     this._touched = t;
   }
   clone(t) {
-    var n, r, a;
-    const e = this.constructor.create(R(_({
-      value: (n = t == null ? void 0 : t.value) != null ? n : this.value
+    var r, a;
+    const e = this.constructor, s = new e(w(v({
+      // an override value is one the caller supplied, and undefined is not one; an explicit null is, and clears
+      value: (t == null ? void 0 : t.value) !== void 0 ? t.value : this.value
     }, t && "originalValue" in t ? { originalValue: t.originalValue } : {}), {
       enabled: (r = t == null ? void 0 : t.enabled) != null ? r : this.enabled,
       visibility: (a = t == null ? void 0 : t.visibility) != null ? a : this.visibility
     }));
-    return e.actions = this.actions.clone(), e.actions.triggerEager(e, e.value, e.originalValue), e;
+    return s.actions = this.actions.clone(), s.actions.triggerEager(s, s.value, s.originalValue), s;
   }
 }
-const Bt = D.create({ value: "EmptyField" }).registerAction(
-  new v(() => {
+const zt = new $({ value: "EmptyField" }).registerAction(
+  new y(() => {
     console.warn("Working with EmptyField! This should not happen");
   })
 );
-function M(i, s) {
-  return (i == null ? void 0 : i.label) == null && (i == null ? void 0 : i.icon) == null ? s : i;
+function H(n, i) {
+  return (n == null ? void 0 : n.label) == null && (n == null ? void 0 : n.icon) == null ? i : n;
 }
-class Dt extends D {
-  constructor(s) {
-    super(s), this._value = { label: void 0, icon: void 0 };
-  }
-  init(s) {
-    if (s) {
-      const t = s, { value: e, originalValue: n, validators: r, actions: a } = t, o = I(t, ["value", "originalValue", "validators", "actions"]);
-      [...r || [], ...a || []].forEach((h) => this.registerAction(h)), Object.assign(this, o);
-      const c = M(e, this._value), u = Object.freeze({ label: n == null ? void 0 : n.label, icon: n == null ? void 0 : n.icon });
-      this._value = M(c, u), this.originalValue = M(u, c);
+class Xt extends $ {
+  init(i) {
+    if (this._value = { label: void 0, icon: void 0 }, i) {
+      const t = i, { value: e, originalValue: s, validators: r, actions: a } = t, l = F(t, ["value", "originalValue", "validators", "actions"]);
+      this.registerInitialActions([...r || [], ...a || []]), Object.assign(this, l);
+      const u = H(e, this._value), d = Object.freeze({ label: s == null ? void 0 : s.label, icon: s == null ? void 0 : s.icon });
+      this._value = H(u, v({}, d)), this.originalValue = H(d, u);
     }
     this.actions.triggerEager(this, this.value, this.originalValue), this.validate();
   }
-  static create(s) {
-    return super.create(s);
-  }
   get icon() {
     return this.value.icon;
   }
-  set icon(s) {
-    this.value.icon = s;
+  set icon(i) {
+    this.value.icon = i;
   }
   get label() {
     return this.value.label;
   }
-  set label(s) {
-    this.value.label = s;
+  set label(i) {
+    this.value.label = i;
   }
-  execute(s) {
-    this.actions.trigger(ht, this, s);
+  execute(i) {
+    this.actions.trigger(ft, this, i);
   }
 }
-const $t = /* @__PURE__ */ xt({
+const Gt = /* @__PURE__ */ It({
   __name: "messages-widget",
   props: {
     message: {},
     classes: {}
   },
-  setup(i) {
-    const s = i, t = tt("vue-markdown"), e = /* @__PURE__ */ new Set([
+  setup(n) {
+    const i = n, t = st("vue-markdown"), e = /* @__PURE__ */ new Set([
       "div",
       "span",
       "p",
@@ -748,37 +856,37 @@ const $t = /* @__PURE__ */ xt({
       "dl",
       "dt",
       "dd"
-    ]), n = () => {
-      if (typeof s.message == "string") return S("span", { class: s.classes }, s.message);
+    ]), s = () => {
+      if (typeof i.message == "string") return j("span", { class: i.classes }, i.message);
       const r = [];
-      return s.message.forEach((a) => {
+      return i.message.forEach((a) => {
         switch (a.componentName) {
           case "template":
-            r.push(S("div", { class: [s.classes, a.extraClasses] }, a.componentBody));
+            r.push(j("div", { class: [i.classes, a.extraClasses] }, a.componentBody));
             break;
           case "vue-markdown":
             if (typeof t == "string")
               console.warn(
                 "You are using markdown for messages-widget, but you haven't registered a vue-markdown component"
-              ), r.push(S("div", { class: [s.classes, a.extraClasses] }, a.componentBindings.source));
+              ), r.push(j("div", { class: [i.classes, a.extraClasses] }, a.componentBindings.source));
             else {
-              const o = a.componentBindings;
+              const l = a.componentBindings;
               r.push(
-                S(t, {
-                  class: [s.classes, a.extraClasses, "df-messages-widget-markdown"],
-                  source: o.source,
-                  options: o.options,
-                  plugins: o.plugins
+                j(t, {
+                  class: [i.classes, a.extraClasses, "df-messages-widget-markdown"],
+                  source: l.source,
+                  options: l.options,
+                  plugins: l.plugins
                 })
               );
             }
             break;
           default:
             r.push(
-              S(
-                e.has(a.componentName.toLowerCase()) ? a.componentName : tt(a.componentName),
-                _(_({
-                  class: [s.classes, a.extraClasses]
+              j(
+                e.has(a.componentName.toLowerCase()) ? a.componentName : st(a.componentName),
+                v(v({
+                  class: [i.classes, a.extraClasses]
                 }, a.componentBindings), a.componentBody ? { innerHTML: a.componentBody } : {})
               )
             );
@@ -786,45 +894,38 @@ const $t = /* @__PURE__ */ xt({
         }
       }), r;
     };
-    return (r, a) => (Et(), _t(n));
+    return (r, a) => (At(), St(s));
   }
 });
-class E extends y {
+class C extends V {
   constructor(t, e) {
     super();
-    l(this, "_fields");
-    l(this, "_value", null);
-    l(this, "reactiveValue", G(() => this.value));
-    l(this, "suppressNotifyValueChanged", !1);
-    if (!E.isValidFields(t)) throw new Error("Invalid fields object provided");
-    if (this._fields = {}, Object.entries(t).forEach(([r, a]) => this.addField(r, a)), e) {
-      const n = e, { value: r, validators: a, actions: o } = n, c = I(n, ["value", "validators", "actions"]);
-      [...a || [], ...o || []].forEach((u) => this.registerAction(u)), Object.assign(this, c), this.value = r != null ? r : this.originalValue;
+    o(this, "_fields");
+    o(this, "_value", null);
+    o(this, "suppressNotifyValueChanged", !1);
+    if (!C.isValidFields(t)) throw new Error("Invalid fields object provided");
+    if (this._fields = /* @__PURE__ */ Object.create(null), Object.entries(t).forEach(([r, a]) => this.addField(r, a)), e) {
+      const s = e, { value: r, validators: a, actions: l } = s, u = F(s, ["value", "validators", "actions"]);
+      this.registerInitialActions([...a || [], ...l || []]), Object.assign(this, u), r !== void 0 ? this.assignMembers(r) : this.originalValue !== void 0 && this.assignMembers(this.originalValue);
     }
-    this.originalValue === void 0 && (this.originalValue = this.value), this.actions.triggerEager(this, this.value, this.originalValue), this.validate();
+    this.originalValue === void 0 && (this.originalValue = this.value), this._value = this.value, this.actions.triggerEager(this, this.value, this.originalValue), this.validate();
   }
   addField(t, e) {
-    if (this.fields[t] !== void 0)
+    if (Object.hasOwn(this._fields, t))
       throw new Error(`Field ${t} is already in this form`);
-    Object.defineProperty(e, "parent", { get: () => this, configurable: !1, enumerable: !1 }), Object.defineProperty(e, "fieldName", { get: () => t, configurable: !1, enumerable: !1 }), Object.defineProperty(this._fields, t, {
-      get() {
-        return e;
-      },
-      configurable: !1,
-      enumerable: !0
-    });
+    Object.defineProperty(e, "parent", { get: () => this, configurable: !1, enumerable: !1 }), Object.defineProperty(e, "fieldName", { get: () => t, configurable: !1, enumerable: !1 }), Object.defineProperty(this._fields, t, { get: () => e, configurable: !1, enumerable: !0 });
   }
   static isValidFields(t) {
-    function e(n) {
-      return n instanceof y;
+    function e(s) {
+      return s instanceof V;
     }
-    return typeof t == "object" && t !== null && Object.entries(t).every(([, n]) => e(n));
+    return typeof t == "object" && t !== null && Object.entries(t).every(([, s]) => e(s));
   }
   static createFromFormData(t) {
-    if (t instanceof y)
+    if (t instanceof V)
       throw new Error("data is already a Form structure, should be a simple object");
-    return new E(
-      t == null ? {} : Object.fromEntries(Object.entries(t).map(([e, n]) => [e, D.create({ value: n })]))
+    return new C(
+      t == null ? {} : Object.fromEntries(Object.entries(t).map(([e, s]) => [e, new $({ value: s })]))
     );
   }
   field(t) {
@@ -835,22 +936,32 @@ class E extends y {
     return this._fields;
   }
   get value() {
-    const t = {};
-    return Object.entries(this._fields).forEach(([e, n]) => {
-      const r = n.value;
-      (n.enabled || n instanceof E && !H(r)) && (t[e] = r);
-    }), H(t) ? null : t;
+    const t = /* @__PURE__ */ Object.create(null);
+    return Object.entries(this._fields).forEach(([e, s]) => {
+      const r = s.value;
+      (s.enabled || s instanceof C && !Q(r)) && (t[e] = r);
+    }), Q(t) ? null : v({}, t);
   }
-  set value(t) {
-    this.suppressNotifyValueChanged = !0;
+  /**
+   * Writes the members that the given value carries, without letting any single member announce the state in
+   * between: the group's own value notification and its own validation are both held back for the duration, so
+   * neither a ValueChangedAction nor a ValidChangedAction reports a verdict over a half-applied value. The
+   * caller decides what to announce once the whole value is in place. Both flags are restored to what they were,
+   * so a caller that is itself holding the group back stays in charge.
+   */
+  assignMembers(t) {
+    const e = this.suppressNotifyValueChanged, s = this.suppressValidation;
+    this.suppressNotifyValueChanged = !0, this.suppressValidation = !0;
     try {
-      Object.entries(this._fields).forEach(([e, n]) => {
-        (t == null || e in t) && (n.value = t == null ? null : t[e]);
+      Object.entries(this._fields).forEach(([r, a]) => {
+        (t == null || Object.hasOwn(t, r)) && (a.value = t == null ? null : t[r]);
       });
     } finally {
-      this.suppressNotifyValueChanged = !1;
+      this.suppressNotifyValueChanged = e, this.suppressValidation = s;
     }
-    this.notifyValueChanged(), this.validate();
+  }
+  set value(t) {
+    this.assignMembers(t), this.notifyValueChanged(), this.validate();
   }
   get touched() {
     return Object.values(this._fields).some((t) => t.touched);
@@ -861,67 +972,100 @@ class E extends y {
     });
   }
   get fullValue() {
-    const t = {};
-    return Object.entries(this._fields).forEach(([e, n]) => {
-      t[e] = n.fullValue;
-    }), t;
+    const t = /* @__PURE__ */ Object.create(null);
+    return Object.entries(this._fields).forEach(([e, s]) => {
+      t[e] = s.fullValue;
+    }), v({}, t);
   }
   notifyValueChanged() {
     if (this.suppressNotifyValueChanged) return;
     const t = this.value;
-    if (!k(t, this._value)) {
+    if (!D(t, this._value)) {
       const e = this._value;
-      this._value = t, this.actions.trigger(v, this, t, e), this.parent && this.parent.notifyValueChanged(), this.validate();
+      this._value = t;
+      const s = this.suppressParentValidityClimb;
+      this.suppressParentValidityClimb = !0;
+      try {
+        this.actions.trigger(y, this, t, e), this.parent && this.parent.notifyValueChanged();
+      } finally {
+        this.suppressParentValidityClimb = s, this.validate(), this.flushParentValidityClimb();
+      }
     }
   }
   get valid() {
     return super.valid && Object.values(this._fields).every((t) => t.valid);
   }
   validate(t = !1) {
-    t && Object.values(this._fields).forEach((e) => e.validate(!0)), super.validate(t);
+    if (t) {
+      const e = this.suppressValidation;
+      this.suppressValidation = !0;
+      try {
+        Object.values(this._fields).forEach((s) => s.validate(!0));
+      } finally {
+        this.suppressValidation = e;
+      }
+    }
+    super.validate(t);
   }
   clone(t) {
-    var r, a, o;
-    const e = {};
-    Object.entries(this._fields).forEach(([c, u]) => {
-      e[c] = u.clone();
+    var r, a;
+    const e = /* @__PURE__ */ Object.create(null);
+    Object.entries(this._fields).forEach(([l, u]) => {
+      e[l] = u.clone();
     });
-    const n = new E(e, R(_({
-      value: (r = t == null ? void 0 : t.value) != null ? r : this.value
+    const s = new C(e, w(v({
+      // an override value is one the caller supplied, and undefined is not one; an explicit null is, and clears
+      value: (t == null ? void 0 : t.value) !== void 0 ? t.value : this.value
     }, t && "originalValue" in t ? { originalValue: t.originalValue } : {}), {
-      enabled: (a = t == null ? void 0 : t.enabled) != null ? a : this.enabled,
-      visibility: (o = t == null ? void 0 : t.visibility) != null ? o : this.visibility
+      enabled: (r = t == null ? void 0 : t.enabled) != null ? r : this.enabled,
+      visibility: (a = t == null ? void 0 : t.visibility) != null ? a : this.visibility
     }));
-    return n.actions = this.actions.clone(), n.actions.triggerEager(n, n.value, n.originalValue), n;
+    return s.actions = this.actions.clone(), s.actions.triggerEager(s, s.value, s.originalValue), s;
   }
 }
-class Y extends y {
+class Y extends V {
   constructor(t, e) {
     super();
-    l(this, "_value", null);
-    l(this, "_itemTemplate");
-    l(this, "_previousValue");
+    o(this, "_value", null);
+    o(this, "_itemTemplate");
+    o(this, "_previousValue");
     if (this._itemTemplate = t, e) {
-      const n = e, { value: r, validators: a, actions: o } = n, c = I(n, ["value", "validators", "actions"]);
-      [...a || [], ...o || []].forEach((u) => this.registerAction(u)), Object.assign(this, c), r && this.setValueInternal(r);
+      const s = e, { value: r, validators: a, actions: l } = s, u = F(s, ["value", "validators", "actions"]);
+      this.registerInitialActions([...a || [], ...l || []]), Object.assign(this, u), r != null && this.setValueInternal(r);
     }
     this.originalValue === void 0 && (this.originalValue = this.value), this._previousValue = this.value, this.actions.triggerEager(this, this.value, this.originalValue), this.validate();
   }
   processSetValueItem(t) {
     let e;
-    return t instanceof E ? e = t : this._itemTemplate ? e = this._itemTemplate.clone({ value: t }) : e = E.createFromFormData(t), Object.defineProperty(e, "parent", { get: () => this, configurable: !1, enumerable: !1 }), e;
+    return t instanceof C ? e = t : this._itemTemplate ? e = this._itemTemplate.clone({ value: t }) : e = C.createFromFormData(t), Object.defineProperty(e, "parent", { get: () => this, configurable: !1, enumerable: !1 }), e;
+  }
+  /**
+   * Builds the item that fills a gap left by an insert beyond the end of the list: a copy of the item template with
+   * the template's own values, or an empty group when the list has no template.
+   */
+  createPaddingItem() {
+    return this.processSetValueItem(this._itemTemplate ? this._itemTemplate.clone() : null);
   }
   setValueInternal(t) {
-    Array.isArray(t) && (this._value = t.map((e) => this.processSetValueItem(e)));
+    t == null ? this._value = null : Array.isArray(t) && (this._value = t.map((e) => this.processSetValueItem(e)));
   }
   get value() {
     var e;
-    const t = (e = this._value) == null ? void 0 : e.map((n) => n.value);
-    return H(t) ? null : t;
+    const t = (e = this._value) == null ? void 0 : e.map((s) => s.value);
+    return Q(t) ? null : t;
   }
   set value(t) {
-    const e = this.value;
-    this.setValueInternal(t), this.actions.trigger(v, this, this.value, e), this.parent && this.parent.notifyValueChanged(), this.validate();
+    const e = this._previousValue;
+    this.setValueInternal(t);
+    const s = this.value;
+    this._previousValue = s;
+    const r = this.suppressParentValidityClimb;
+    this.suppressParentValidityClimb = !0;
+    try {
+      this.actions.trigger(y, this, s, e), this.parent && this.parent.notifyValueChanged();
+    } finally {
+      this.suppressParentValidityClimb = r, this.validate(), this.flushParentValidityClimb();
+    }
   }
   get touched() {
     var t;
@@ -929,283 +1073,286 @@ class Y extends y {
   }
   set touched(t) {
     var e;
-    (e = this._value) == null || e.forEach((n) => {
-      n.touched = t;
+    (e = this._value) == null || e.forEach((s) => {
+      s.touched = t;
     });
   }
   clone(t) {
-    var n, r, a, o;
-    const e = new Y((n = this._itemTemplate) == null ? void 0 : n.clone(), R(_({
-      value: [...(r = t == null ? void 0 : t.value) != null ? r : this.value]
+    var s, r, a, l;
+    const e = new Y((s = this._itemTemplate) == null ? void 0 : s.clone(), w(v({
+      // an override value is one the caller supplied, and undefined is not one; an explicit null is, and clears
+      value: [...(r = (t == null ? void 0 : t.value) !== void 0 ? t.value : this.value) != null ? r : []]
     }, t && "originalValue" in t ? { originalValue: t.originalValue } : {}), {
       enabled: (a = t == null ? void 0 : t.enabled) != null ? a : this.enabled,
-      visibility: (o = t == null ? void 0 : t.visibility) != null ? o : this.visibility
+      visibility: (l = t == null ? void 0 : t.visibility) != null ? l : this.visibility
     }));
     return e.actions = this.actions.clone(), e.actions.triggerEager(e, e.value, e.originalValue), e;
   }
   notifyValueChanged() {
     const t = this.value;
-    if (!k(t, this._previousValue)) {
+    if (!D(t, this._previousValue)) {
       const e = this._previousValue;
-      this._previousValue = t, this.actions.trigger(v, this, t, e), this.parent && this.parent.notifyValueChanged(), this.validate();
+      this._previousValue = t;
+      const s = this.suppressParentValidityClimb;
+      this.suppressParentValidityClimb = !0;
+      try {
+        this.actions.trigger(y, this, t, e), this.parent && this.parent.notifyValueChanged();
+      } finally {
+        this.suppressParentValidityClimb = s, this.validate(), this.flushParentValidityClimb();
+      }
     }
   }
   get valid() {
     var t, e;
-    return super.valid && ((e = (t = this._value) == null ? void 0 : t.every((n) => n.valid)) != null ? e : !0);
+    return super.valid && ((e = (t = this._value) == null ? void 0 : t.every((s) => s.valid)) != null ? e : !0);
   }
   validate(t = !1) {
     var e;
-    t && ((e = this._value) == null || e.forEach((n) => n.validate(!0))), super.validate(t);
+    if (t) {
+      const s = this.suppressValidation;
+      this.suppressValidation = !0;
+      try {
+        (e = this._value) == null || e.forEach((r) => r.validate(!0));
+      } finally {
+        this.suppressValidation = s;
+      }
+    }
+    super.validate(t);
   }
   get(t) {
     return this._value != null ? this._value[t] : void 0;
   }
   push(t) {
-    var e, n;
-    return this.insert(t, (n = (e = this._value) == null ? void 0 : e.length) != null ? n : 0) + 1;
+    var e, s;
+    return this.insert(t, (s = (e = this._value) == null ? void 0 : e.length) != null ? s : 0) + 1;
   }
   pop() {
     var t, e;
     return this.remove(((e = (t = this._value) == null ? void 0 : t.length) != null ? e : 0) - 1);
   }
   remove(t) {
-    var n;
+    var s;
     if (this._value == null || t < 0 || this._value.length <= t) return;
-    let e = (n = this._value.splice(t, 1)) == null ? void 0 : n[0];
-    return e && (e = e.clone(), this.actions.trigger(dt, this, e, t), this.notifyValueChanged()), e;
+    let e = (s = this._value.splice(t, 1)) == null ? void 0 : s[0];
+    return e && (e = e.clone(), this.actions.trigger(pt, this, e, t), this.notifyValueChanged()), e;
   }
   insert(t, e) {
-    for (this._value == null && (this._value = []); this._value.length < e; ) {
-      const r = this.processSetValueItem(null), a = this._value.push(r);
-      this.actions.trigger(z, this, r, a);
+    this._value == null && (this._value = []);
+    const s = e < 0 ? Math.max(this._value.length + e, 0) : e;
+    for (; this._value.length < s; ) {
+      const a = this.createPaddingItem(), l = this._value.push(a) - 1;
+      this.actions.trigger(z, this, a, l);
     }
-    const n = this.processSetValueItem(t);
-    return this._value.splice(e, 0, n), this.actions.trigger(z, this, n, e), this.notifyValueChanged(), e;
+    const r = this.processSetValueItem(t);
+    return this._value.splice(s, 0, r), this.actions.trigger(z, this, r, s), this.notifyValueChanged(), s;
   }
   clear() {
     this._value = null, this.notifyValueChanged();
   }
 }
-const gt = { useMarkdownInValidators: !0 };
-function qt() {
-  return gt;
-}
-function Mt(i) {
-  Object.assign(gt, i);
-}
-const re = {
-  install(i, s) {
-    s && Mt(s);
-  }
-};
-function m(i) {
-  return qt().useMarkdownInValidators ? new N(i) : i.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, `
-`);
-}
-class Ht extends f {
-  constructor(t, e, n) {
-    let r = !1, a, o;
-    super((u, h, A) => (a = u, o = h, r || (r = !0, this.otherField.registerAction(
-      new v((x, j, P, $) => {
-        j(x, P, $), this.unregistered || this.execute(A, () => null, a, o);
+class Yt extends f {
+  constructor(t, e, s) {
+    let r = !1, a, l;
+    super((d, x, _) => (a = d, l = x, r || (r = !0, this.otherField.registerAction(
+      new y((P, B, p, E) => {
+        B(P, p, E), this.unregistered || this.execute(_, () => null, a, l);
       })
-    )), this.isValidComparison(g(u), g(this.otherField.value)) ? null : [
-      new p(
-        this.replacePlaceholders(n, { newValue: u, oldValue: h, field: A, otherField: this.otherField })
+    )), this.isValidComparison(h(d), h(this.otherField.value)) ? null : [
+      new g(
+        this.replacePlaceholders(s, { newValue: d, oldValue: x, field: _, otherField: this.otherField })
       )
     ]));
-    l(this, "otherField");
-    l(this, "isValidComparison");
-    l(this, "unregistered", !1);
+    o(this, "otherField");
+    o(this, "isValidComparison");
+    o(this, "unregistered", !1);
     this.otherField = t, this.isValidComparison = e;
   }
   unregister() {
     this.unregistered = !0;
   }
 }
-class Qt extends f {
-  constructor(s, t) {
-    const e = t || m("Must be one of [**{allowedAsText}**]");
-    let n = s.join(", ");
-    n.length > 60 && (n = mt(n, {
+class Jt extends f {
+  constructor(i, t) {
+    const e = t || b("Must be one of [**{allowedAsText}**]");
+    let s = i.join(", ");
+    s.length > 60 && (s = Ct(s, {
       length: 40,
       separator: ", ",
-      omission: `... (${s.length} items total)`
+      omission: `... (${i.length} items total)`
     }));
-    const r = (a, o, c) => s.includes(g(a)) ? null : [
-      new p(
-        this.replacePlaceholders(e, { newValue: a, oldValue: o, field: c, allowedValues: s, allowedAsText: n })
+    const r = (a, l, u) => i.includes(h(a)) ? null : [
+      new g(
+        this.replacePlaceholders(e, { newValue: a, oldValue: l, field: u, allowedValues: i, allowedAsText: s })
       )
     ];
     super(r);
   }
 }
-function zt(i) {
-  return i == null ? 0 : nt(i) || C(i) ? i.length : it(i) && Object.getPrototypeOf(i) === Object.prototype ? Object.keys(i).length : String(i).length;
+function Kt(n) {
+  return n == null ? 0 : rt(n) || A(n) ? n.length : at(n) && Object.getPrototypeOf(n) === Object.prototype ? Object.keys(n).length : String(n).length;
 }
-class Gt extends f {
-  constructor(s) {
-    const t = s || m("Please enter a value"), e = (n, r, a) => zt(g(n)) === 0 ? [new p(this.replacePlaceholders(t, { newValue: n, oldValue: r, field: a }))] : null;
+class Zt extends f {
+  constructor(i) {
+    const t = i || b("Please enter a value"), e = (s, r, a) => Kt(h(s)) === 0 ? [new g(this.replacePlaceholders(t, { newValue: s, oldValue: r, field: a }))] : null;
     super(e);
   }
 }
-class Wt extends f {
-  constructor(s, t) {
-    const e = t || m("Value must be larger or equal to **{minValue}**"), n = (r, a, o) => r < s || r === void 0 ? [
-      new p(this.replacePlaceholders(e, { newValue: r, oldValue: a, field: o, minValue: s }))
+class te extends f {
+  constructor(i, t) {
+    const e = t || b("Value must be larger or equal to **{minValue}**"), s = (r, a, l) => r < i || r === void 0 ? [
+      new g(this.replacePlaceholders(e, { newValue: r, oldValue: a, field: l, minValue: i }))
     ] : null;
-    super(n);
+    super(s);
   }
 }
-class Xt extends f {
-  constructor(s, t) {
-    const e = t || m("Value must be less than or equal to **{maxValue}**"), n = (r, a, o) => r > s || r === void 0 ? [
-      new p(this.replacePlaceholders(e, { newValue: r, oldValue: a, field: o, maxValue: s }))
+class ee extends f {
+  constructor(i, t) {
+    const e = t || b("Value must be less than or equal to **{maxValue}**"), s = (r, a, l) => r > i || r === void 0 ? [
+      new g(this.replacePlaceholders(e, { newValue: r, oldValue: a, field: l, maxValue: i }))
     ] : null;
-    super(n);
+    super(s);
   }
 }
-class Yt extends f {
-  constructor(s, t, e) {
-    const n = e || m("Value must be between **{minValue}** and **{maxValue}**"), r = (a, o, c) => a < s || a > t || a === void 0 ? [
-      new p(
-        this.replacePlaceholders(n, { newValue: a, oldValue: o, field: c, minValue: s, maxValue: t })
+class ie extends f {
+  constructor(i, t, e) {
+    const s = e || b("Value must be between **{minValue}** and **{maxValue}**"), r = (a, l, u) => a < i || a > t || a === void 0 ? [
+      new g(
+        this.replacePlaceholders(s, { newValue: a, oldValue: l, field: u, minValue: i, maxValue: t })
       )
     ] : null;
     super(r);
   }
 }
-function J(i) {
-  return i == null ? 0 : nt(i) || C(i) ? i.length : it(i) && Object.getPrototypeOf(i) === Object.prototype ? Object.keys(i).length : String(i).length;
+function J(n) {
+  return n == null ? 0 : rt(n) || A(n) ? n.length : at(n) && Object.getPrototypeOf(n) === Object.prototype ? Object.keys(n).length : String(n).length;
 }
-class Jt extends f {
-  constructor(s, t) {
-    const e = t || m("Length must be larger or equal to **{minLength}**"), n = (r, a, o) => J(r) < s ? [
-      new p(this.replacePlaceholders(e, { newValue: r, oldValue: a, field: o, minLength: s }))
+class se extends f {
+  constructor(i, t) {
+    const e = t || b("Length must be larger or equal to **{minLength}**"), s = (r, a, l) => J(r) < i ? [
+      new g(this.replacePlaceholders(e, { newValue: r, oldValue: a, field: l, minLength: i }))
     ] : null;
-    super(n);
+    super(s);
   }
 }
-class Kt extends f {
-  constructor(s, t) {
-    const e = t || m("Length must be less than or equal to **{maxLength}**"), n = (r, a, o) => J(r) > s ? [
-      new p(this.replacePlaceholders(e, { newValue: r, oldValue: a, field: o, maxLength: s }))
+class ne extends f {
+  constructor(i, t) {
+    const e = t || b("Length must be less than or equal to **{maxLength}**"), s = (r, a, l) => J(r) > i ? [
+      new g(this.replacePlaceholders(e, { newValue: r, oldValue: a, field: l, maxLength: i }))
     ] : null;
-    super(n);
+    super(s);
   }
 }
-class Zt extends f {
-  constructor(s, t, e) {
-    const n = e || m("Length must be between **{minLength}** and **{maxLength}**"), r = (a, o, c) => {
-      const u = J(a);
-      return u < s || u > t ? [
-        new p(
-          this.replacePlaceholders(n, { newValue: a, oldValue: o, field: c, minLength: s, maxLength: t })
+class re extends f {
+  constructor(i, t, e) {
+    const s = e || b("Length must be between **{minLength}** and **{maxLength}**"), r = (a, l, u) => {
+      const d = J(a);
+      return d < i || d > t ? [
+        new g(
+          this.replacePlaceholders(s, { newValue: a, oldValue: l, field: u, minLength: i, maxLength: t })
         )
       ] : null;
     };
     super(r);
   }
 }
-class te extends f {
-  constructor(s, t) {
-    const e = t || m('Value must match pattern "**{pattern}**"'), n = (r, a, o) => s.test(String(g(r))) ? null : [
-      new p(this.replacePlaceholders(e, { newValue: r, oldValue: a, field: o, pattern: s }))
+class ae extends f {
+  constructor(i, t) {
+    const e = t || b('Value must match pattern "**{pattern}**"'), s = (r, a, l) => i.test(String(h(r))) ? null : [
+      new g(this.replacePlaceholders(e, { newValue: r, oldValue: a, field: l, pattern: i }))
     ];
-    super(n);
+    super(s);
   }
 }
-const ee = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+const le = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
-  CompareTo: Ht,
-  InAllowedValues: Qt,
-  LengthInRange: Zt,
-  MaxLength: Kt,
-  MaxValue: Xt,
-  MinLength: Jt,
-  MinValue: Wt,
-  Pattern: te,
-  Required: Gt,
+  CompareTo: Yt,
+  InAllowedValues: Jt,
+  LengthInRange: re,
+  MaxLength: ne,
+  MaxValue: ee,
+  MinLength: se,
+  MinValue: te,
+  Pattern: ae,
+  Required: Zt,
   Validator: f,
-  ValueInRange: Yt
-}, Symbol.toStringTag, { value: "Module" })), ae = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  ValueInRange: ie
+}, Symbol.toStringTag, { value: "Module" })), de = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
-  AbortEventHandlingException: Q,
-  Action: Dt,
-  ActionsMap: T,
-  ConditionalEnabledAction: Ft,
-  ConditionalStatementAction: B,
-  ConditionalValueAction: wt,
-  ConditionalVisibilityAction: St,
-  DisplayMode: V,
-  EmptyField: Bt,
-  EnabledChangedAction: ot,
-  EnabledChangingAction: at,
-  ExecuteAction: ht,
-  Field: D,
-  FieldActionBase: b,
-  FieldBase: y,
-  Group: E,
+  AbortEventHandlingException: W,
+  Action: Xt,
+  ActionsMap: L,
+  ConditionalEnabledAction: Rt,
+  ConditionalStatementAction: M,
+  ConditionalValueAction: Bt,
+  ConditionalVisibilityAction: Lt,
+  DisplayMode: S,
+  EmptyField: zt,
+  EnabledChangedAction: ct,
+  EnabledChangingAction: ut,
+  ExecuteAction: ft,
+  Field: $,
+  FieldActionBase: m,
+  FieldBase: V,
+  Group: C,
   List: Y,
   ListItemAddedAction: z,
-  ListItemRemovedAction: dt,
-  MdString: N,
-  MessagesWidget: $t,
-  Operator: d,
-  RenderableValue: Vt,
-  Statement: F,
-  ValidChangedAction: lt,
-  ValidationError: X,
-  ValidationErrorRenderContent: p,
-  ValidationErrorText: Ct,
+  ListItemRemovedAction: pt,
+  MdString: O,
+  MessagesWidget: Gt,
+  Operator: c,
+  RenderableValue: jt,
+  Statement: N,
+  ValidChangedAction: ht,
+  ValidationError: G,
+  ValidationErrorRenderContent: g,
+  ValidationErrorText: Ft,
   Validator: f,
-  Validators: ee,
-  ValueChangedAction: v,
-  VisibilityChangedAction: ut,
-  VisibilityChangingAction: ct,
-  buildErrorMessage: m,
-  isCallableFunction: U,
-  isSimpleComponentDef: W
+  Validators: le,
+  ValueChangedAction: y,
+  VisibilityChangedAction: gt,
+  VisibilityChangingAction: dt,
+  buildErrorMessage: b,
+  isCallableFunction: k,
+  isSimpleComponentDef: X
 }, Symbol.toStringTag, { value: "Module" }));
 export {
-  Q as AbortEventHandlingException,
-  Dt as Action,
-  T as ActionsMap,
-  Ft as ConditionalEnabledAction,
-  B as ConditionalStatementAction,
-  wt as ConditionalValueAction,
-  St as ConditionalVisibilityAction,
-  V as DisplayMode,
-  Bt as EmptyField,
-  ot as EnabledChangedAction,
-  at as EnabledChangingAction,
-  ht as ExecuteAction,
-  D as Field,
-  b as FieldActionBase,
-  y as FieldBase,
-  E as Group,
+  W as AbortEventHandlingException,
+  Xt as Action,
+  L as ActionsMap,
+  Rt as ConditionalEnabledAction,
+  M as ConditionalStatementAction,
+  Bt as ConditionalValueAction,
+  Lt as ConditionalVisibilityAction,
+  S as DisplayMode,
+  zt as EmptyField,
+  ct as EnabledChangedAction,
+  ut as EnabledChangingAction,
+  ft as ExecuteAction,
+  $ as Field,
+  m as FieldActionBase,
+  V as FieldBase,
+  C as Group,
   Y as List,
   z as ListItemAddedAction,
-  dt as ListItemRemovedAction,
-  N as MdString,
-  $t as MessagesWidget,
-  d as Operator,
-  Vt as RenderableValue,
-  F as Statement,
-  lt as ValidChangedAction,
-  X as ValidationError,
-  p as ValidationErrorRenderContent,
-  Ct as ValidationErrorText,
+  pt as ListItemRemovedAction,
+  O as MdString,
+  Gt as MessagesWidget,
+  c as Operator,
+  jt as RenderableValue,
+  N as Statement,
+  ht as ValidChangedAction,
+  G as ValidationError,
+  g as ValidationErrorRenderContent,
+  Ft as ValidationErrorText,
   f as Validator,
-  ee as Validators,
-  v as ValueChangedAction,
-  ut as VisibilityChangedAction,
-  ct as VisibilityChangingAction,
-  m as buildErrorMessage,
-  ae as default,
-  re as forms,
-  U as isCallableFunction,
-  W as isSimpleComponentDef
+  le as Validators,
+  y as ValueChangedAction,
+  gt as VisibilityChangedAction,
+  dt as VisibilityChangingAction,
+  b as buildErrorMessage,
+  de as default,
+  he as forms,
+  k as isCallableFunction,
+  X as isSimpleComponentDef
 };
 //# sourceMappingURL=dynamicforms-vue-forms.js.map