@dynamicforms/vue-forms 0.6.0 → 0.6.1

package/dist/dynamicforms-vue-forms.js

@@ -1,51 +1,51 @@
-var de = Object.defineProperty, ge = Object.defineProperties;
-var fe = Object.getOwnPropertyDescriptors;
-var P = Object.getOwnPropertySymbols;
-var J = Object.prototype.hasOwnProperty, K = Object.prototype.propertyIsEnumerable;
-var q = (i, s, e) => s in i ? de(i, s, { enumerable: !0, configurable: !0, writable: !0, value: e }) : i[s] = e, y = (i, s) => {
-  for (var e in s || (s = {}))
-    J.call(s, e) && q(i, e, s[e]);
-  if (P)
-    for (var e of P(s))
-      K.call(s, e) && q(i, e, s[e]);
-  return i;
-}, R = (i, s) => ge(i, fe(s));
-var I = (i, s) => {
-  var e = {};
-  for (var t in i)
-    J.call(i, t) && s.indexOf(t) < 0 && (e[t] = i[t]);
-  if (i != null && P)
-    for (var t of P(i))
-      s.indexOf(t) < 0 && K.call(i, t) && (e[t] = i[t]);
-  return e;
+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 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 o = (i, s, e) => q(i, typeof s != "symbol" ? s + "" : s, e);
-import { isEqual as k, isBoolean as pe, isString as V, isEmpty as H, truncate as be, isArray as te, isObject as se } from "lodash-es";
-import { unref as g, computed as me, reactive as ve, defineComponent as ye, resolveComponent as Z, openBlock as xe, createBlock as Ee, h as S } from "vue";
-var F = /* @__PURE__ */ ((i) => (i[i.SUPPRESS = 1] = "SUPPRESS", i[i.HIDDEN = 5] = "HIDDEN", i[i.INVISIBLE = 8] = "INVISIBLE", i[i.FULL = 10] = "FULL", i))(F || {});
-const ee = 10;
-((i) => {
-  function s(n) {
-    return n.toUpperCase() === "SUPPRESS" ? 1 : n.toUpperCase() === "HIDDEN" ? 5 : n.toUpperCase() === "INVISIBLE" ? 8 : ee;
-  }
-  i.fromString = s;
-  function e(n) {
-    const r = typeof n == "number" ? n : i.fromString(n);
-    return Object.values(i).includes(r) ? r : ee;
-  }
-  i.fromAny = e;
-  function t(n) {
-    const r = typeof n == "number" ? n : i.fromString(n);
-    return Object.values(i).includes(r);
-  }
-  i.isDefined = t;
-})(F || (F = {}));
-Object.freeze(F);
-const C = F;
-class b {
-  constructor(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 = s;
+    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, e, ...t) {
-    return this.executorFn(s, e, ...t);
+  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 ne = /* @__PURE__ */ Symbol("ValueChangedAction");
-class m extends b {
-  constructor(s) {
-    super(s);
+const lt = /* @__PURE__ */ Symbol("ValueChangedAction");
+class y extends m {
+  constructor(i) {
+    super(i);
   }
   static get classIdentifier() {
-    return ne;
+    return lt;
   }
-  execute(s, e, t, n) {
-    return super.execute(s, e, t, n);
+  execute(i, t, e, s) {
+    return super.execute(i, t, e, s);
   }
 }
-class j extends String {
-  constructor(e, t, n) {
-    super(e);
+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);
     o(this, "plugins");
     o(this, "options");
-    this.plugins = n, this.options = t;
+    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,12 +120,12 @@ class X {
     return "";
   }
 }
-class _e extends X {
-  constructor(e, t = "") {
+class Ft extends G {
+  constructor(t, e = "") {
     super();
     o(this, "text");
     o(this, "classes");
-    this.text = e, this.classes = t;
+    this.text = t, this.classes = e;
   }
   get componentName() {
     return "template";
@@ -125,24 +137,24 @@ class _e extends X {
     return this.classes;
   }
 }
-class p extends X {
-  constructor(e, t = "") {
+class g extends G {
+  constructor(t, e = "") {
     super();
     o(this, "classes");
     o(this, "text");
     o(this, "textType");
-    this.classes = t, this.text = e, this.textType = me(() => this.getTextType);
+    this.classes = e, this.text = t, this.textType = xt(() => this.getTextType);
   }
   get resolvedText() {
-    const e = g(this.text);
-    return U(e) ? e() : e;
+    const t = h(this.text);
+    return k(t) ? t() : t;
   }
   get getTextType() {
-    const e = this.resolvedText;
-    return e ? e instanceof j ? "md" : W(e) ? "component" : "string" : "string";
+    const t = this.resolvedText;
+    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,12 +166,12 @@ class p extends X {
     }
   }
   get componentBindings() {
-    switch (g(this.textType)) {
+    switch (h(this.textType)) {
       case "string":
         return {};
       case "md": {
-        const e = this.resolvedText;
-        return { source: e.toString(), options: e.options, plugins: e.plugins };
+        const t = this.resolvedText;
+        return { source: t.toString(), options: t.options, plugins: t.plugins };
       }
       case "component":
         return this.resolvedText.componentProps || {};
@@ -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,158 +193,195 @@ class p extends X {
     return this.classes;
   }
 }
-class Ve 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 Ce = /* @__PURE__ */ Symbol("Validator");
-class f extends m {
+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(e) {
-    super((n, r, a, l) => {
-      const c = e(a, l, n) || [], u = (h) => {
-        var A;
-        h == null || h.forEach(
-          (E) => Object.defineProperty(E, "source", { value: this.source, enumerable: !1, configurable: !1 })
-        );
-        for (let E = n.errors.length - 1; E >= 0; E--) {
-          const L = n.errors[E];
-          if (L.source === this.source) {
-            const O = (A = h == null ? void 0 : h.findIndex(($) => k($, L))) != null ? A : -1;
-            O >= 0 ? h == null || h.splice(O, 1) : n.errors.splice(E, 1);
+  constructor(t) {
+    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.beginValidating(), c.then((h) => u(h)).finally(() => n.endValidating())) : u(c), r(n, a, l);
+      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);
     });
     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 Ce;
+    return Nt;
   }
   get eager() {
     return !0;
   }
-  replacePlaceholdersFunction(e, t) {
+  replacePlaceholdersFunction(t, e) {
     return () => {
-      let n = g(e);
-      for (; U(n); )
-        n = g(this.replacePlaceholders(n(), t));
-      return n;
+      let s = h(t);
+      for (; k(s); )
+        s = h(this.replacePlaceholders(s(), e));
+      return s;
     };
   }
-  replacePlaceholders(e, t) {
-    if (U(e)) return this.replacePlaceholdersFunction(e, t);
-    if (W(e)) return e;
-    let n = g(e);
-    return Object.keys(t).forEach((r) => {
-      n = n.replaceAll(`{${r}}`, t[r]);
-    }), e instanceof j ? new j(n.toString(), e.options, e.plugins) : n;
+  replacePlaceholders(t, e) {
+    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) => {
+      s = s.replaceAll(`{${r}}`, e[r]);
+    }), t instanceof O ? new O(s.toString(), t.options, t.plugins) : s;
   }
 }
-class N extends Map {
+class L extends Map {
   constructor() {
     super(...arguments);
     o(this, "eagerActions", /* @__PURE__ */ new Set());
     o(this, "registeredActions", []);
   }
-  register(e) {
-    if (!(e instanceof b)) throw new Error("Invalid action type");
-    this.registeredActions.push(e);
-    const t = e.classIdentifier, n = this.get(t) || (() => null);
+  register(t) {
+    if (!(t instanceof m)) throw new Error("Invalid action type");
+    this.registeredActions.push(t);
+    const e = t.classIdentifier, s = this.get(e) || (() => null);
     function r(a, ...l) {
-      return e.execute(a, n, ...l);
+      return t.execute(a, s, ...l);
     }
-    this.set(t, r), e.eager && this.eagerActions.add(e.classIdentifier);
+    this.set(e, r), t.eager && this.eagerActions.add(t.classIdentifier);
   }
-  trigger(e, t, ...n) {
-    const r = e.classIdentifier;
-    r === ne && this.triggerEager(t, ...n);
+  trigger(t, e, ...s) {
+    const r = t.classIdentifier;
+    r === lt && this.triggerEager(e, ...s);
     const a = this.get(r);
     try {
-      if (a) return a(t, ...n);
+      if (a) return a(e, ...s);
     } catch (l) {
-      if (!(l instanceof Q)) throw l;
+      if (!(l instanceof W)) throw l;
     }
     return null;
   }
-  triggerEager(e, ...t) {
-    for (const n of this.eagerActions) {
-      const r = this.get(n);
+  triggerEager(t, ...e) {
+    for (const s of this.eagerActions) {
+      const r = this.get(s);
       try {
-        r && r(e, ...t);
+        r && r(t, ...e);
       } catch (a) {
-        if (!(a instanceof Q)) throw a;
+        if (!(a instanceof W)) throw a;
       }
     }
   }
   clone() {
-    const e = new N();
-    return this.registeredActions.forEach((t) => e.register(t)), e;
+    const t = new L();
+    return this.registeredActions.forEach((e) => t.register(e)), t;
   }
   cloneWithoutValidators() {
-    const e = new N();
-    return this.registeredActions.forEach((t) => {
-      t instanceof f ? t.unregister() : e.register(t);
-    }), e;
+    const t = new L();
+    return this.registeredActions.forEach((e) => {
+      e instanceof f ? e.unregister() : t.register(e);
+    }), t;
   }
 }
-const Ae = /* @__PURE__ */ Symbol("ConditionalStatementAction");
-class B extends m {
-  constructor(e, t) {
-    const n = (r, a, l, c) => {
-      const u = e.evaluate();
-      if (u !== this.lastResult) {
-        for (const h of this.boundFields)
-          t(h, u, this.lastResult);
-        this.lastResult = u;
+const Ot = /* @__PURE__ */ Symbol("ConditionalStatementAction");
+class M extends y {
+  constructor(t, e) {
+    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, l, c);
+      return a(r, l, u);
     };
-    super(n);
+    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
     o(this, "boundFields", /* @__PURE__ */ new Set());
-    e.collectFields().forEach((r) => r.registerAction(new m(n)));
+    t.collectFields().forEach((r) => r.registerAction(new y(s)));
   }
   static get classIdentifier() {
-    return Ae;
+    return Ot;
   }
   get eager() {
     return !0;
   }
-  boundToField(e) {
-    this.boundFields.add(e);
+  boundToField(t) {
+    this.boundFields.add(t);
   }
 }
-class Ie extends B {
-  constructor(s) {
-    super(s, (e, t) => {
-      e.visibility = t ? C.FULL : C.SUPPRESS;
+class Lt extends M {
+  constructor(i) {
+    super(i, (t, e) => {
+      t.visibility = e ? S.FULL : S.SUPPRESS;
     });
   }
 }
-class Se extends B {
-  constructor(s) {
-    super(s, (e, t) => {
-      e.enabled = t;
+class Rt extends M {
+  constructor(i) {
+    super(i, (t, e) => {
+      t.enabled = e;
     });
   }
 }
-class we extends B {
-  constructor(s, e) {
-    super(s, (t, n) => {
-      n && (t.value = e);
+class Bt extends M {
+  constructor(i, t) {
+    super(i, (e, s) => {
+      s && (e.value = t);
     });
   }
 }
-var T = /* @__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))(T || {});
-((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;
@@ -352,85 +401,85 @@ var T = /* @__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;
-  function e(r) {
-    const a = typeof r == "number" ? r : i.fromString(r);
-    if (Object.values(i).includes(a)) return a;
+  n.fromString = i;
+  function t(r) {
+    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 = e;
-  function t(r) {
-    const a = typeof r == "number" ? r : i.fromString(r);
-    return Object.values(i).includes(a);
+  n.fromAny = t;
+  function e(r) {
+    const a = typeof r == "number" ? r : n.fromString(r);
+    return Object.values(n).includes(a);
   }
-  i.isDefined = t;
-  function n(r) {
+  n.isDefined = e;
+  function s(r) {
     return r >= 0;
   }
-  i.isLogicOperator = n;
-})(T || (T = {}));
-Object.freeze(T);
-const d = T, Fe = /* @__PURE__ */ Symbol("EnabledChangingAction");
-class ie 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 Fe;
+    return Ut;
   }
-  execute(s, e, t, n) {
-    return super.execute(s, e, t, n);
+  execute(i, t, e, s) {
+    return super.execute(i, t, e, s);
   }
 }
-const je = /* @__PURE__ */ Symbol("EnabledChangedAction");
-class re extends b {
-  constructor(s) {
-    super(s);
+const kt = /* @__PURE__ */ Symbol("EnabledChangedAction");
+class ct extends m {
+  constructor(i) {
+    super(i);
   }
   static get classIdentifier() {
-    return je;
+    return kt;
   }
-  execute(s, e, t, n) {
-    return super.execute(s, e, t, n);
+  execute(i, t, e, s) {
+    return super.execute(i, t, e, s);
   }
 }
-const Ne = /* @__PURE__ */ Symbol("ValidChangedAction");
-class ae extends b {
-  constructor(s) {
-    super(s);
+const Dt = /* @__PURE__ */ Symbol("ValidChangedAction");
+class ht extends m {
+  constructor(i) {
+    super(i);
   }
   static get classIdentifier() {
-    return Ne;
+    return Dt;
   }
-  execute(s, e, t, n) {
-    return super.execute(s, e, t, n);
+  execute(i, t, e, s) {
+    return super.execute(i, t, e, s);
   }
 }
-const Te = /* @__PURE__ */ Symbol("VisibilityChangingAction");
-class le extends b {
-  constructor(s) {
-    super(s);
+const Mt = /* @__PURE__ */ Symbol("VisibilityChangingAction");
+class dt extends m {
+  constructor(i) {
+    super(i);
   }
   static get classIdentifier() {
-    return Te;
+    return Mt;
   }
-  execute(s, e, t, n) {
-    return super.execute(s, e, t, n);
+  execute(i, t, e, s) {
+    return super.execute(i, t, e, s);
   }
 }
-const Le = /* @__PURE__ */ Symbol("VisibilityChangedAction");
-class oe extends b {
-  constructor(s) {
-    super(s);
+const $t = /* @__PURE__ */ Symbol("VisibilityChangedAction");
+class gt extends m {
+  constructor(i) {
+    super(i);
   }
   static get classIdentifier() {
-    return Le;
+    return $t;
   }
-  execute(s, e, t, n) {
-    return super.execute(s, e, t, n);
+  execute(i, t, e, s) {
+    return super.execute(i, t, e, s);
   }
 }
-class x {
+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
@@ -443,11 +492,29 @@ class x {
     // is current value valid as per FE and BE validators?
     o(this, "errors", []);
     // when member of a Group, fieldName specifies the name of this field
-    o(this, "actions", new N());
+    o(this, "actions", new L());
     // default property handlers
-    o(this, "_visibility", C.FULL);
+    o(this, "_visibility", S.FULL);
     o(this, "_enabled", !0);
-    return ve(this);
+    /**
+     * 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() {
@@ -464,23 +531,30 @@ class x {
   get visibility() {
     return this._visibility;
   }
-  set visibility(s) {
-    const e = this._visibility, t = this.actions.trigger(le, this, s, e);
-    if (!C.isDefined(t != null ? t : s)) throw new Error("visibility must be a DisplayMode constant");
-    this._visibility = C.fromAny(t != null ? t : s), this.actions.trigger(oe, this, this._visibility, e);
+  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 e = this._enabled, t = this.actions.trigger(ie, this, s, e);
-    if (!pe(t != null ? t : s)) throw new Error("Enabled value must be boolean");
-    this._enabled = t != null ? t : s, this.actions.trigger(re, this, this._enabled, e);
+  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);
+  }
+  /** 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(s = !1) {
-    s && this.actions.triggerEager(this, this.value, this.value);
-    const e = this._valid;
-    this._valid = this.valid, this._valid !== e && this.actions.trigger(ae, this, this.valid, e);
+  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(ht, this, this.valid, t), this.suppressParentValidityClimb ? this.parentValidityClimbPending = !0 : (e = this.parent) == null || e.validate());
   }
   get valid() {
     return this.errors.length === 0;
@@ -489,72 +563,94 @@ class x {
     return this.value;
   }
   get isChanged() {
-    return !k(this.value, this.originalValue);
+    return !D(this.value, this.originalValue);
   }
-  registerAction(s) {
-    return this.actions.register(s), s.boundToField(this), s.eager && this.actions.trigger(Object.getPrototypeOf(s).constructor, this, this.value, this.originalValue), this;
+  /**
+   * 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);
+    });
   }
-  triggerAction(s, ...e) {
-    return this.actions.trigger(s, this, ...e);
+  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(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 Oe(i, s) {
-  return i ? !s : s;
+function qt(n, i) {
+  return n ? !i : i;
 }
-class w {
-  constructor(s, e, t) {
+class N {
+  constructor(i, t, e) {
     o(this, "operand1");
     o(this, "operator");
     o(this, "operand2");
-    this.operand1 = s, this.operator = e, this.operand2 = t;
+    this.operand1 = i, this.operator = t, this.operand2 = e;
   }
   get operand1Value() {
-    return this.operand1 instanceof w ? this.operand1.evaluate() : this.operand1 instanceof x ? 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 w ? this.operand2.evaluate() : this.operand2 instanceof x ? 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 t, n, r, a;
-    const s = this.operand1Value, e = this.operand2Value;
+    var e, s;
+    const i = this.operand1Value, t = this.operand2Value;
     switch (this.operator) {
       // logical operators
-      case d.AND:
-        return s && e;
-      case d.OR:
-        return s || e;
-      case d.NAND:
-        return !(s && e);
-      case d.NOR:
-        return !(s || e);
-      case d.XOR:
-        return Oe(s, e);
-      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 == e;
-      case d.NOT_EQUALS:
-        return s != e;
-      case d.LT:
-        return s < e;
-      case d.LE:
-        return s <= e;
-      case d.GE:
-        return s >= e;
-      case d.GT:
-        return s > e;
-      case d.IN:
-        return (n = (t = e == null ? void 0 : e.includes) == null ? void 0 : t.call(e, s)) != null ? n : !1;
-      case d.NOT_IN:
-        return !((a = (r = e == null ? void 0 : e.includes) == null ? void 0 : r.call(e, s)) == null || a);
-      case d.INCLUDES:
-        return V(s) && V(e) && s.indexOf(e) >= 0;
-      case d.NOT_INCLUDES:
-        return !(V(s) && V(e) && s.indexOf(e) >= 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}`);
     }
@@ -564,55 +660,55 @@ class w {
    * @returns A set of all fields used in this statement
    */
   collectFields() {
-    const s = /* @__PURE__ */ new Set();
-    function e(t) {
-      t instanceof x ? s.add(t) : t instanceof w && t.collectFields().forEach((r) => s.add(r));
+    const i = /* @__PURE__ */ new Set();
+    function t(e) {
+      e instanceof V ? i.add(e) : e instanceof N && e.collectFields().forEach((r) => i.add(r));
     }
-    return e(this.operand1), e(this.operand2), s;
+    return t(this.operand1), t(this.operand2), i;
   }
 }
-const Pe = /* @__PURE__ */ Symbol("ExecuteAction");
-class ce extends b {
-  constructor(s) {
-    super(s);
+const Ht = /* @__PURE__ */ Symbol("ExecuteAction");
+class ft extends m {
+  constructor(i) {
+    super(i);
   }
   static get classIdentifier() {
-    return Pe;
+    return Ht;
   }
-  execute(s, e, t) {
-    return super.execute(s, e, t);
+  execute(i, t, e) {
+    return super.execute(i, t, e);
   }
 }
-const Re = /* @__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 Re;
+    return Qt;
   }
-  execute(s, e, t, n) {
-    return super.execute(s, e, t, n);
+  execute(i, t, e, s) {
+    return super.execute(i, t, e, s);
   }
 }
-const Ue = /* @__PURE__ */ Symbol("ListItemRemovedAction");
-class ue extends b {
-  constructor(s) {
-    super(s);
+const Wt = /* @__PURE__ */ Symbol("ListItemRemovedAction");
+class pt extends m {
+  constructor(i) {
+    super(i);
   }
   static get classIdentifier() {
-    return Ue;
+    return Wt;
   }
-  execute(s, e, t, n) {
-    return super.execute(s, e, t, n);
+  execute(i, t, e, s) {
+    return super.execute(i, t, e, s);
   }
 }
-class D extends x {
-  constructor(e) {
+class $ extends V {
+  constructor(t) {
     super();
     o(this, "_value");
     o(this, "_touched", !1);
-    this.init(e);
+    this.init(t);
   }
   /**
    * Applies the constructor parameters. It is a hook so that a subclass needing different parameter handling
@@ -623,79 +719,88 @@ class D extends x {
    * subclass initializes read as undefined inside it, and anything it writes to such a member is overwritten
    * the moment the initializer runs.
    */
-  init(e) {
-    if (e) {
-      const t = e, { value: n, validators: r, actions: a } = t, l = I(t, ["value", "validators", "actions"]);
-      [...r || [], ...a || []].forEach((c) => this.registerAction(c)), Object.assign(this, l), this._value = n != null ? n : this.originalValue, this.originalValue === void 0 && (this.originalValue = this._value);
+  init(t) {
+    if (t) {
+      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();
   }
   get value() {
     return this._value;
   }
-  set value(e) {
-    const t = this._value;
-    !this.enabled || t === e || (this._value = e, this.actions.trigger(m, this, this._value, t), this.parent && this.parent.notifyValueChanged(), this.validate());
+  set value(t) {
+    const e = this._value;
+    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;
   }
-  set touched(e) {
-    this._touched = e;
-  }
-  clone(e) {
-    var r, a, l;
-    const t = this.constructor, n = new t(R(y({
-      value: (r = e == null ? void 0 : e.value) != null ? r : this.value
-    }, e && "originalValue" in e ? { originalValue: e.originalValue } : {}), {
-      enabled: (a = e == null ? void 0 : e.enabled) != null ? a : this.enabled,
-      visibility: (l = e == null ? void 0 : e.visibility) != null ? l : this.visibility
+  set touched(t) {
+    this._touched = t;
+  }
+  clone(t) {
+    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 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;
   }
 }
-const ke = new D({ value: "EmptyField" }).registerAction(
-  new m(() => {
+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 Be extends D {
-  init(s) {
-    if (this._value = { label: void 0, icon: void 0 }, s) {
-      const e = s, { value: t, originalValue: n, validators: r, actions: a } = e, l = I(e, ["value", "originalValue", "validators", "actions"]);
-      [...r || [], ...a || []].forEach((h) => this.registerAction(h)), Object.assign(this, l);
-      const c = M(t, this._value), u = Object.freeze({ label: n == null ? void 0 : n.label, icon: n == null ? void 0 : n.icon });
-      this._value = M(c, y({}, 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();
   }
   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(ce, this, s);
+  execute(i) {
+    this.actions.trigger(ft, this, i);
   }
 }
-const De = /* @__PURE__ */ ye({
+const Gt = /* @__PURE__ */ It({
   __name: "messages-widget",
   props: {
     message: {},
     classes: {}
   },
-  setup(i) {
-    const s = i, e = Z("vue-markdown"), t = /* @__PURE__ */ new Set([
+  setup(n) {
+    const i = n, t = st("vue-markdown"), e = /* @__PURE__ */ new Set([
       "div",
       "span",
       "p",
@@ -751,24 +856,24 @@ const De = /* @__PURE__ */ ye({
       "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 e == "string")
+            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 l = a.componentBindings;
               r.push(
-                S(e, {
-                  class: [s.classes, a.extraClasses, "df-messages-widget-markdown"],
+                j(t, {
+                  class: [i.classes, a.extraClasses, "df-messages-widget-markdown"],
                   source: l.source,
                   options: l.options,
                   plugins: l.plugins
@@ -778,10 +883,10 @@ const De = /* @__PURE__ */ ye({
             break;
           default:
             r.push(
-              S(
-                t.has(a.componentName.toLowerCase()) ? a.componentName : Z(a.componentName),
-                y(y({
-                  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 } : {})
               )
             );
@@ -789,419 +894,465 @@ const De = /* @__PURE__ */ ye({
         }
       }), r;
     };
-    return (r, a) => (xe(), Ee(n));
+    return (r, a) => (At(), St(s));
   }
 });
-class _ extends x {
-  constructor(e, t) {
+class C extends V {
+  constructor(t, e) {
     super();
     o(this, "_fields");
     o(this, "_value", null);
     o(this, "suppressNotifyValueChanged", !1);
-    if (!_.isValidFields(e)) throw new Error("Invalid fields object provided");
-    if (this._fields = /* @__PURE__ */ Object.create(null), Object.entries(e).forEach(([r, a]) => this.addField(r, a)), t) {
-      const n = t, { value: r, validators: a, actions: l } = n, c = I(n, ["value", "validators", "actions"]);
-      [...a || [], ...l || []].forEach((u) => this.registerAction(u)), Object.assign(this, c), this.value = r != null ? r : this.originalValue;
+    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(e, t) {
-    if (Object.hasOwn(this._fields, e))
-      throw new Error(`Field ${e} is already in this form`);
-    Object.defineProperty(t, "parent", { get: () => this, configurable: !1, enumerable: !1 }), Object.defineProperty(t, "fieldName", { get: () => e, configurable: !1, enumerable: !1 }), Object.defineProperty(this._fields, e, { get: () => t, configurable: !1, enumerable: !0 });
+  addField(t, e) {
+    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: () => e, configurable: !1, enumerable: !0 });
   }
-  static isValidFields(e) {
-    function t(n) {
-      return n instanceof x;
+  static isValidFields(t) {
+    function e(s) {
+      return s instanceof V;
     }
-    return typeof e == "object" && e !== null && Object.entries(e).every(([, n]) => t(n));
+    return typeof t == "object" && t !== null && Object.entries(t).every(([, s]) => e(s));
   }
-  static createFromFormData(e) {
-    if (e instanceof x)
+  static createFromFormData(t) {
+    if (t instanceof V)
       throw new Error("data is already a Form structure, should be a simple object");
-    return new _(
-      e == null ? {} : Object.fromEntries(Object.entries(e).map(([t, n]) => [t, new D({ value: n })]))
+    return new C(
+      t == null ? {} : Object.fromEntries(Object.entries(t).map(([e, s]) => [e, new $({ value: s })]))
     );
   }
-  field(e) {
-    var t;
-    return (t = this._fields[e]) != null ? t : null;
+  field(t) {
+    var e;
+    return (e = this._fields[t]) != null ? e : null;
   }
   get fields() {
     return this._fields;
   }
   get value() {
-    const e = /* @__PURE__ */ Object.create(null);
-    return Object.entries(this._fields).forEach(([t, n]) => {
-      const r = n.value;
-      (n.enabled || n instanceof _ && !H(r)) && (e[t] = r);
-    }), H(e) ? null : y({}, e);
+    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(e) {
-    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(([t, n]) => {
-        (e == null || Object.hasOwn(e, t)) && (n.value = e == null ? null : e[t]);
+      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((e) => e.touched);
+    return Object.values(this._fields).some((t) => t.touched);
   }
-  set touched(e) {
-    Object.values(this._fields).forEach((t) => {
-      t.touched = e;
+  set touched(t) {
+    Object.values(this._fields).forEach((e) => {
+      e.touched = t;
     });
   }
   get fullValue() {
-    const e = /* @__PURE__ */ Object.create(null);
-    return Object.entries(this._fields).forEach(([t, n]) => {
-      e[t] = n.fullValue;
-    }), y({}, e);
+    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 e = this.value;
-    if (!k(e, this._value)) {
-      const t = this._value;
-      this._value = e, this.actions.trigger(m, this, e, t), this.parent && this.parent.notifyValueChanged(), this.validate();
+    const t = this.value;
+    if (!D(t, this._value)) {
+      const e = this._value;
+      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((e) => e.valid);
+    return super.valid && Object.values(this._fields).every((t) => t.valid);
   }
-  validate(e = !1) {
-    e && Object.values(this._fields).forEach((t) => t.validate(!0)), super.validate(e);
+  validate(t = !1) {
+    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(e) {
-    var r, a, l;
-    const t = /* @__PURE__ */ Object.create(null);
-    Object.entries(this._fields).forEach(([c, u]) => {
-      t[c] = u.clone();
+  clone(t) {
+    var r, a;
+    const e = /* @__PURE__ */ Object.create(null);
+    Object.entries(this._fields).forEach(([l, u]) => {
+      e[l] = u.clone();
     });
-    const n = new _(t, R(y({
-      value: (r = e == null ? void 0 : e.value) != null ? r : this.value
-    }, e && "originalValue" in e ? { originalValue: e.originalValue } : {}), {
-      enabled: (a = e == null ? void 0 : e.enabled) != null ? a : this.enabled,
-      visibility: (l = e == null ? void 0 : e.visibility) != null ? l : this.visibility
+    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: (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 G extends x {
-  constructor(e, t) {
+class Y extends V {
+  constructor(t, e) {
     super();
     o(this, "_value", null);
     o(this, "_itemTemplate");
     o(this, "_previousValue");
-    if (this._itemTemplate = e, t) {
-      const n = t, { value: r, validators: a, actions: l } = n, c = I(n, ["value", "validators", "actions"]);
-      [...a || [], ...l || []].forEach((u) => this.registerAction(u)), Object.assign(this, c), r && this.setValueInternal(r);
+    if (this._itemTemplate = t, 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 != 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(e) {
-    let t;
-    return e instanceof _ ? t = e : this._itemTemplate ? t = this._itemTemplate.clone({ value: e }) : t = _.createFromFormData(e), Object.defineProperty(t, "parent", { get: () => this, configurable: !1, enumerable: !1 }), t;
-  }
-  setValueInternal(e) {
-    Array.isArray(e) && (this._value = e.map((t) => this.processSetValueItem(t)));
+  processSetValueItem(t) {
+    let 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;
   }
-  get value() {
-    var t;
-    const e = (t = this._value) == null ? void 0 : t.map((n) => n.value);
-    return H(e) ? null : 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);
   }
-  set value(e) {
-    const t = this.value;
-    this.setValueInternal(e), this.actions.trigger(m, this, this.value, t), this.parent && this.parent.notifyValueChanged(), this.validate();
+  setValueInternal(t) {
+    t == null ? this._value = null : Array.isArray(t) && (this._value = t.map((e) => this.processSetValueItem(e)));
   }
-  get touched() {
+  get value() {
     var e;
-    return ((e = this._value) == null ? void 0 : e.some((t) => t.touched)) || !1;
+    const t = (e = this._value) == null ? void 0 : e.map((s) => s.value);
+    return Q(t) ? null : t;
+  }
+  set value(t) {
+    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();
+    }
   }
-  set touched(e) {
+  get touched() {
     var t;
-    (t = this._value) == null || t.forEach((n) => {
-      n.touched = e;
+    return ((t = this._value) == null ? void 0 : t.some((e) => e.touched)) || !1;
+  }
+  set touched(t) {
+    var e;
+    (e = this._value) == null || e.forEach((s) => {
+      s.touched = t;
     });
   }
-  clone(e) {
-    var n, r, a, l, c;
-    const t = new G((n = this._itemTemplate) == null ? void 0 : n.clone(), R(y({
-      value: [...(a = (r = e == null ? void 0 : e.value) != null ? r : this.value) != null ? a : []]
-    }, e && "originalValue" in e ? { originalValue: e.originalValue } : {}), {
-      enabled: (l = e == null ? void 0 : e.enabled) != null ? l : this.enabled,
-      visibility: (c = e == null ? void 0 : e.visibility) != null ? c : this.visibility
+  clone(t) {
+    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: (l = t == null ? void 0 : t.visibility) != null ? l : this.visibility
     }));
-    return t.actions = this.actions.clone(), t.actions.triggerEager(t, t.value, t.originalValue), t;
+    return e.actions = this.actions.clone(), e.actions.triggerEager(e, e.value, e.originalValue), e;
   }
   notifyValueChanged() {
-    const e = this.value;
-    if (!k(e, this._previousValue)) {
-      const t = this._previousValue;
-      this._previousValue = e, this.actions.trigger(m, this, e, t), this.parent && this.parent.notifyValueChanged(), this.validate();
+    const t = this.value;
+    if (!D(t, this._previousValue)) {
+      const e = this._previousValue;
+      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 e, t;
-    return super.valid && ((t = (e = this._value) == null ? void 0 : e.every((n) => n.valid)) != null ? t : !0);
+    var t, e;
+    return super.valid && ((e = (t = this._value) == null ? void 0 : t.every((s) => s.valid)) != null ? e : !0);
   }
-  validate(e = !1) {
-    var t;
-    e && ((t = this._value) == null || t.forEach((n) => n.validate(!0))), super.validate(e);
+  validate(t = !1) {
+    var e;
+    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(e) {
-    return this._value != null ? this._value[e] : void 0;
+  get(t) {
+    return this._value != null ? this._value[t] : void 0;
   }
-  push(e) {
-    var t, n;
-    return this.insert(e, (n = (t = this._value) == null ? void 0 : t.length) != null ? n : 0) + 1;
+  push(t) {
+    var e, s;
+    return this.insert(t, (s = (e = this._value) == null ? void 0 : e.length) != null ? s : 0) + 1;
   }
   pop() {
-    var e, t;
-    return this.remove(((t = (e = this._value) == null ? void 0 : e.length) != null ? t : 0) - 1);
-  }
-  remove(e) {
-    var n;
-    if (this._value == null || e < 0 || this._value.length <= e) return;
-    let t = (n = this._value.splice(e, 1)) == null ? void 0 : n[0];
-    return t && (t = t.clone(), this.actions.trigger(ue, this, t, e), this.notifyValueChanged()), t;
-  }
-  insert(e, t) {
-    for (this._value == null && (this._value = []); this._value.length < t; ) {
-      const r = this.processSetValueItem(null), a = this._value.push(r);
-      this.actions.trigger(z, this, r, a);
+    var t, e;
+    return this.remove(((e = (t = this._value) == null ? void 0 : t.length) != null ? e : 0) - 1);
+  }
+  remove(t) {
+    var s;
+    if (this._value == null || t < 0 || this._value.length <= t) return;
+    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) {
+    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(e);
-    return this._value.splice(t, 0, n), this.actions.trigger(z, this, n, t), this.notifyValueChanged(), t;
+    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 he = { useMarkdownInValidators: !0 };
-function $e() {
-  return he;
-}
-function qe(i) {
-  Object.assign(he, i);
-}
-const it = {
-  install(i, s) {
-    s && qe(s);
-  }
-};
-function v(i) {
-  return $e().useMarkdownInValidators ? new j(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 Me extends f {
-  constructor(e, t, n) {
+class Yt extends f {
+  constructor(t, e, s) {
     let r = !1, a, l;
-    super((u, h, A) => (a = u, l = h, r || (r = !0, this.otherField.registerAction(
-      new m((E, L, O, $) => {
-        L(E, O, $), this.unregistered || this.execute(A, () => null, 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 })
       )
     ]));
     o(this, "otherField");
     o(this, "isValidComparison");
     o(this, "unregistered", !1);
-    this.otherField = e, this.isValidComparison = t;
+    this.otherField = t, this.isValidComparison = e;
   }
   unregister() {
     this.unregistered = !0;
   }
 }
-class He extends f {
-  constructor(s, e) {
-    const t = e || v("Must be one of [**{allowedAsText}**]");
-    let n = s.join(", ");
-    n.length > 60 && (n = be(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, l, c) => s.includes(g(a)) ? null : [
-      new p(
-        this.replacePlaceholders(t, { newValue: a, oldValue: l, 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 Qe(i) {
-  return i == null ? 0 : te(i) || V(i) ? i.length : se(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 ze extends f {
-  constructor(s) {
-    const e = s || v("Please enter a value"), t = (n, r, a) => Qe(g(n)) === 0 ? [new p(this.replacePlaceholders(e, { newValue: n, oldValue: r, field: a }))] : null;
-    super(t);
+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 We extends f {
-  constructor(s, e) {
-    const t = e || v("Value must be larger or equal to **{minValue}**"), n = (r, a, l) => r < s || r === void 0 ? [
-      new p(this.replacePlaceholders(t, { newValue: r, oldValue: a, field: l, 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 Xe extends f {
-  constructor(s, e) {
-    const t = e || v("Value must be less than or equal to **{maxValue}**"), n = (r, a, l) => r > s || r === void 0 ? [
-      new p(this.replacePlaceholders(t, { newValue: r, oldValue: a, field: l, 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 Ge extends f {
-  constructor(s, e, t) {
-    const n = t || v("Value must be between **{minValue}** and **{maxValue}**"), r = (a, l, c) => a < s || a > e || a === void 0 ? [
-      new p(
-        this.replacePlaceholders(n, { newValue: a, oldValue: l, field: c, minValue: s, maxValue: e })
+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 Y(i) {
-  return i == null ? 0 : te(i) || V(i) ? i.length : se(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 Ye extends f {
-  constructor(s, e) {
-    const t = e || v("Length must be larger or equal to **{minLength}**"), n = (r, a, l) => Y(r) < s ? [
-      new p(this.replacePlaceholders(t, { newValue: r, oldValue: a, field: l, 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 Je extends f {
-  constructor(s, e) {
-    const t = e || v("Length must be less than or equal to **{maxLength}**"), n = (r, a, l) => Y(r) > s ? [
-      new p(this.replacePlaceholders(t, { newValue: r, oldValue: a, field: l, 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 Ke extends f {
-  constructor(s, e, t) {
-    const n = t || v("Length must be between **{minLength}** and **{maxLength}**"), r = (a, l, c) => {
-      const u = Y(a);
-      return u < s || u > e ? [
-        new p(
-          this.replacePlaceholders(n, { newValue: a, oldValue: l, field: c, minLength: s, maxLength: e })
+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 Ze extends f {
-  constructor(s, e) {
-    const t = e || v('Value must match pattern "**{pattern}**"'), n = (r, a, l) => s.test(String(g(r))) ? null : [
-      new p(this.replacePlaceholders(t, { newValue: r, oldValue: a, field: l, 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 et = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+const le = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
-  CompareTo: Me,
-  InAllowedValues: He,
-  LengthInRange: Ke,
-  MaxLength: Je,
-  MaxValue: Xe,
-  MinLength: Ye,
-  MinValue: We,
-  Pattern: Ze,
-  Required: ze,
+  CompareTo: Yt,
+  InAllowedValues: Jt,
+  LengthInRange: re,
+  MaxLength: ne,
+  MaxValue: ee,
+  MinLength: se,
+  MinValue: te,
+  Pattern: ae,
+  Required: Zt,
   Validator: f,
-  ValueInRange: Ge
-}, Symbol.toStringTag, { value: "Module" })), rt = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  ValueInRange: ie
+}, Symbol.toStringTag, { value: "Module" })), de = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
-  AbortEventHandlingException: Q,
-  Action: Be,
-  ActionsMap: N,
-  ConditionalEnabledAction: Se,
-  ConditionalStatementAction: B,
-  ConditionalValueAction: we,
-  ConditionalVisibilityAction: Ie,
-  DisplayMode: C,
-  EmptyField: ke,
-  EnabledChangedAction: re,
-  EnabledChangingAction: ie,
-  ExecuteAction: ce,
-  Field: D,
-  FieldActionBase: b,
-  FieldBase: x,
-  Group: _,
-  List: G,
+  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: ue,
-  MdString: j,
-  MessagesWidget: De,
-  Operator: d,
-  RenderableValue: Ve,
-  Statement: w,
-  ValidChangedAction: ae,
-  ValidationError: X,
-  ValidationErrorRenderContent: p,
-  ValidationErrorText: _e,
+  ListItemRemovedAction: pt,
+  MdString: O,
+  MessagesWidget: Gt,
+  Operator: c,
+  RenderableValue: jt,
+  Statement: N,
+  ValidChangedAction: ht,
+  ValidationError: G,
+  ValidationErrorRenderContent: g,
+  ValidationErrorText: Ft,
   Validator: f,
-  Validators: et,
-  ValueChangedAction: m,
-  VisibilityChangedAction: oe,
-  VisibilityChangingAction: le,
-  buildErrorMessage: v,
-  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,
-  Be as Action,
-  N as ActionsMap,
-  Se as ConditionalEnabledAction,
-  B as ConditionalStatementAction,
-  we as ConditionalValueAction,
-  Ie as ConditionalVisibilityAction,
-  C as DisplayMode,
-  ke as EmptyField,
-  re as EnabledChangedAction,
-  ie as EnabledChangingAction,
-  ce as ExecuteAction,
-  D as Field,
-  b as FieldActionBase,
-  x as FieldBase,
-  _ as Group,
-  G as List,
+  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,
-  ue as ListItemRemovedAction,
-  j as MdString,
-  De as MessagesWidget,
-  d as Operator,
-  Ve as RenderableValue,
-  w as Statement,
-  ae as ValidChangedAction,
-  X as ValidationError,
-  p as ValidationErrorRenderContent,
-  _e 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,
-  et as Validators,
-  m as ValueChangedAction,
-  oe as VisibilityChangedAction,
-  le as VisibilityChangingAction,
-  v as buildErrorMessage,
-  rt as default,
-  it 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