@knime/jsonforms 1.6.9 → 1.7.0

package/dist/MultimodeTwinlistControl-CV2v4Y5n.js

@@ -0,0 +1,526 @@
+import { openBlock as f, createElementBlock as k, createElementVNode as H, toRef as P, resolveComponent as y, normalizeClass as W, createBlock as I, withCtx as V, createVNode as g, createCommentVNode as M, mergeProps as B, ref as L, watch as _, defineComponent as G, computed as h, markRaw as J, unref as U } from "vue";
+import { g as x, a as K, m as Q } from "./index-Blg1O3Fz.js";
+import { u as X, a as Y } from "./usePossibleValues-CrNcBbpN.js";
+import { S as Z, a as $, u as ee, T as te } from "./TwinlistLoadingInfo-BHhpo_7N.js";
+import { f as F } from "./useSearch-hpyYQ_6y.js";
+import { C as le } from "./Checkboxes-C_qM6Iao.js";
+import { n as ae, _ as z } from "./SettingsSubPanel.vue_vue_type_style_index_0_scoped_67b92e23_lang-BM4d25sK.js";
+import { V as ne } from "./ValueSwitch-BI5z5U3F.js";
+const se = {
+  xmlns: "http://www.w3.org/2000/svg",
+  fill: "none",
+  stroke: "#000",
+  "stroke-linejoin": "round",
+  viewBox: "0 0 32 32"
+}, ie = /* @__PURE__ */ H("path", { d: "m13.31 27.81 5.11-3.19v-9.15L28.95 4.19H3.05l10.26 11.28z" }, null, -1), oe = [
+  ie
+];
+function de(e, a) {
+  return f(), k("svg", se, [...oe]);
+}
+const ue = { render: de }, re = {
+  manual: "Manual",
+  wildcard: "Wildcard",
+  regex: "Regex",
+  type: "Type"
+}, ce = {
+  name: "MultiModeTwinlist",
+  components: {
+    Label: ae,
+    FilterIcon: ue,
+    SearchInput: Z,
+    Checkboxes: le,
+    ValueSwitch: ne,
+    Twinlist: $
+  },
+  props: {
+    /**
+     * initial values
+     */
+    mode: {
+      type: String,
+      required: !1,
+      default: "manual"
+    },
+    manualSelection: {
+      type: [Object, Array, null],
+      default: () => []
+    },
+    pattern: {
+      type: String,
+      default: ""
+    },
+    caseSensitivePattern: {
+      default: !1,
+      type: Boolean
+    },
+    inversePattern: {
+      default: !1,
+      type: Boolean
+    },
+    withTypes: {
+      type: Boolean,
+      default: !0
+    },
+    selectedTypes: {
+      type: Array,
+      default: () => []
+    },
+    /**
+     * Hiding and disabling
+     */
+    showMode: {
+      default: !0,
+      type: Boolean
+    },
+    // enable search in case of manual selection
+    showSearch: {
+      default: !0,
+      type: Boolean
+    },
+    disabled: {
+      default: !1,
+      type: Boolean
+    },
+    /**
+     * Labels
+     */
+    withModeLabel: {
+      default: !1,
+      type: Boolean
+    },
+    modeLabel: {
+      type: String,
+      required: !1,
+      default: "Selection mode"
+    },
+    withPatternLabel: {
+      default: !1,
+      type: Boolean
+    },
+    patternLabel: {
+      type: String,
+      required: !1,
+      default: "Pattern"
+    },
+    withTypesLabel: {
+      default: !1,
+      type: Boolean
+    },
+    typesLabel: {
+      type: String,
+      required: !1,
+      default: "Selected types"
+    },
+    /**
+     * List of possible values. Each item must have an `id` and a `text` property
+     * @example
+     * [{
+     *   id: 'pdf',
+     *   text: 'PDF'
+     * }, {
+     *   id: 'XLS',
+     *   text: 'Excel',
+     * }]
+     * For type selection, additionally, an element has to have a property `type` wich itself has properties
+     * `id` and `text`, e.g.
+     * [{
+     *   id: 'pdf',
+     *   text: 'PDF',
+     *   type: {
+     *     id: 'StringValue',
+     *     text: 'String'
+     *  }]
+     */
+    possibleValues: {
+      type: Array,
+      default: () => []
+    },
+    /**
+     * List of possible types which should be selectable but are not necessarily present in the possible values.
+     */
+    additionalPossibleTypes: {
+      type: Array,
+      default: () => []
+    },
+    compact: {
+      type: Boolean,
+      default: !1
+    }
+  },
+  emits: [
+    // Prop updates
+    "update:manualSelection",
+    "update:pattern",
+    "update:selectedTypes",
+    "update:mode",
+    "update:caseSensitivePattern",
+    "update:inversePattern",
+    // Non-prop update
+    "update:selected"
+  ],
+  setup(e) {
+    const { includedValues: a } = ee(
+      P(e, "manualSelection")
+    );
+    return { manuallySelected: a };
+  },
+  data() {
+    return {
+      invalidPossibleValueIds: /* @__PURE__ */ new Set()
+    };
+  },
+  computed: {
+    possibleValueIds() {
+      return this.possibleValues.map(({ id: e }) => e);
+    },
+    possibleTypes() {
+      const e = this.possibleValues.map(({ type: i }) => i).filter(Boolean), a = e.map((i) => i.id);
+      return [...this.additionalPossibleTypes.filter(
+        (i) => i && !a.includes(i.id)
+      ), ...e].filter((i) => i && i.id !== "").filter(
+        // remove duplicates
+        (i, s, d) => s === d.findIndex((u) => u.id === i.id && u.text === i.text)
+      );
+    },
+    matchingValueIds() {
+      return this.possibleValues.filter((e) => this.itemMatches(e)).map((e) => e.id);
+    },
+    twinlistModelValue() {
+      return this.mode === "manual" ? this.manualSelection : this.matchingValueIds;
+    },
+    selectedValues() {
+      return this.mode === "manual" ? this.manuallySelected : this.matchingValueIds;
+    },
+    selectionDisabled() {
+      return this.disabled || this.mode !== "manual";
+    },
+    normalizedSearchTerm() {
+      return this.mode === "manual" ? null : F[this.mode].normalize(
+        this.mode === "type" ? this.selectedTypes : this.pattern,
+        this.caseSensitivePattern
+      );
+    },
+    possibleModes() {
+      let e = Object.entries(re).map(([a, t]) => ({ id: a, text: t }));
+      return this.withTypes || (e = e.filter((a) => a.id !== "type")), e;
+    }
+  },
+  watch: {
+    selectedValues: {
+      immediate: !0,
+      handler(e, a) {
+        !a || e === null || (e.length !== a.length || a.some((t, n) => t !== e[n])) && this.$emit("update:selected", this.selectedValues);
+      }
+    }
+  },
+  methods: {
+    onManualInput(e) {
+      this.mode === "manual" && this.$emit("update:manualSelection", e);
+    },
+    onPatternInput(e) {
+      this.$emit("update:pattern", e);
+    },
+    onTypeInput(e) {
+      this.$emit("update:selectedTypes", e, this.possibleTypes);
+    },
+    onModeChange(e) {
+      this.$emit("update:mode", e);
+    },
+    onToggleCaseSensitivePattern(e) {
+      this.$emit("update:caseSensitivePattern", e);
+    },
+    onToggleInversePattern(e) {
+      this.$emit("update:inversePattern", e);
+    },
+    validate() {
+      return this.$refs.twinlist.validate();
+    },
+    hasSelection() {
+      var e;
+      return !!((e = this.selectedValues) != null && e.length);
+    },
+    itemMatches(e) {
+      var t;
+      return F[this.mode].test(
+        this.mode === "type" ? (t = e.type) == null ? void 0 : t.id : e.text,
+        this.normalizedSearchTerm,
+        this.caseSensitivePattern,
+        this.inversePattern
+      );
+    }
+  }
+};
+function pe(e, a, t, n, i, s) {
+  const d = y("ValueSwitch"), u = y("Label"), b = y("FilterIcon"), w = y("SearchInput"), v = y("Checkboxes"), p = y("Twinlist");
+  return f(), k("div", {
+    class: W(["multi-mode-twinlist", { disabled: t.disabled }])
+  }, [
+    t.showMode ? (f(), I(u, {
+      key: 0,
+      active: t.withModeLabel,
+      text: t.modeLabel,
+      class: "label"
+    }, {
+      default: V(({ labelForId: r }) => [
+        g(d, {
+          id: r,
+          ref: "mode",
+          compact: t.compact,
+          "model-value": t.mode,
+          disabled: t.disabled,
+          "possible-values": s.possibleModes,
+          "onUpdate:modelValue": s.onModeChange
+        }, null, 8, ["id", "compact", "model-value", "disabled", "possible-values", "onUpdate:modelValue"])
+      ]),
+      _: 1
+    }, 8, ["active", "text"])) : M("", !0),
+    t.mode === "regex" || t.mode === "wildcard" ? (f(), I(u, {
+      key: 1,
+      active: t.withPatternLabel,
+      text: t.patternLabel,
+      class: "label"
+    }, {
+      default: V(({ labelForId: r }) => [
+        g(w, {
+          id: r,
+          ref: "search",
+          "model-value": t.pattern,
+          label: t.patternLabel,
+          "initial-case-sensitive-search": t.caseSensitivePattern,
+          "initial-inverse-search": t.inversePattern,
+          placeholder: "Pattern",
+          "show-case-sensitive-search-button": "",
+          "show-inverse-search-button": "",
+          disabled: t.disabled,
+          tooltips: {
+            inverseSearch: "Move matching to other side"
+          },
+          compact: t.compact,
+          "onUpdate:modelValue": s.onPatternInput,
+          onToggleCaseSensitiveSearch: s.onToggleCaseSensitivePattern,
+          onToggleInverseSearch: s.onToggleInversePattern
+        }, {
+          icon: V(() => [
+            g(b)
+          ]),
+          _: 2
+        }, 1032, ["id", "model-value", "label", "initial-case-sensitive-search", "initial-inverse-search", "disabled", "compact", "onUpdate:modelValue", "onToggleCaseSensitiveSearch", "onToggleInverseSearch"])
+      ]),
+      _: 1
+    }, 8, ["active", "text"])) : M("", !0),
+    t.mode === "type" && s.possibleTypes.length > 0 ? (f(), I(u, {
+      key: 2,
+      active: t.withTypesLabel,
+      text: t.typesLabel,
+      class: "label"
+    }, {
+      default: V(() => [
+        g(v, {
+          "model-value": t.selectedTypes,
+          "possible-values": s.possibleTypes,
+          disabled: t.disabled,
+          "onUpdate:modelValue": s.onTypeInput
+        }, null, 8, ["model-value", "possible-values", "disabled", "onUpdate:modelValue"])
+      ]),
+      _: 1
+    }, 8, ["active", "text"])) : M("", !0),
+    g(p, B(e.$attrs, {
+      ref: "twinlist",
+      disabled: s.selectionDisabled,
+      "show-search": t.mode === "manual" && t.showSearch,
+      "model-value": s.twinlistModelValue,
+      "possible-values": t.possibleValues,
+      compact: t.compact,
+      "onUpdate:modelValue": s.onManualInput
+    }), null, 16, ["disabled", "show-search", "model-value", "possible-values", "compact", "onUpdate:modelValue"])
+  ], 2);
+}
+const me = /* @__PURE__ */ z(ce, [["render", pe], ["__scopeId", "data-v-e5a6658e"]]), he = ({
+  knownValuesSide: e,
+  possibleValueIds: a,
+  unknownValuesSide: t
+}) => {
+  const n = new Set(e.previous), i = new Set(a), s = (d) => x(d, i);
+  t.setNext([
+    ...s(t.previous),
+    ...x(a, n)
+  ]), e.setNext([
+    ...s(e.previous),
+    ...K(a, n)
+  ]);
+}, ve = ({
+  data: e,
+  possibleValueIds: a
+}) => {
+  const t = L({
+    selected: null,
+    deselected: null
+  }), n = L(null), i = (d) => {
+    n.value = d;
+  }, s = () => {
+    if (!n.value || !a.value)
+      return;
+    let d, u;
+    const { manuallyDeselected: b, manuallySelected: w, includeUnknownColumns: v } = n.value, p = {
+      previous: b,
+      setNext: (S) => {
+        d = S;
+      }
+    }, r = {
+      previous: w,
+      setNext: (S) => {
+        u = S;
+      }
+    }, T = v ? p : r, C = v ? r : p;
+    he({
+      possibleValueIds: a.value,
+      knownValuesSide: T,
+      unknownValuesSide: C
+    }), t.value = {
+      selected: u,
+      deselected: d
+    };
+  };
+  return _(
+    () => e.value.manualFilter,
+    (d) => {
+      Object.is(n.value, d) ? t.value = {
+        selected: d.manuallySelected,
+        deselected: d.manuallyDeselected
+      } : (n.value = d, s());
+    },
+    { immediate: !0 }
+  ), _(() => a.value, s, {
+    immediate: !0
+  }), { selectedAndDeselected: t, setCurrentManualFilter: i };
+}, ye = /* @__PURE__ */ G({
+  __name: "MultimodeTwinlistControl",
+  props: {
+    control: {},
+    handleChange: {},
+    changeValue: {},
+    disabled: { type: Boolean },
+    isValid: { type: Boolean },
+    onRegisterValidation: {},
+    labelForId: {},
+    twinlistSize: { default: 10 },
+    twinlistLeftLabel: { default: "Excludes" },
+    showUnknownValues: { type: Boolean, default: !1 },
+    twinlistRightLabel: { default: "Includes" }
+  },
+  setup(e) {
+    const a = e;
+    let t;
+    const n = (l) => {
+      const o = Q(a.control.data, l);
+      a.changeValue(o), t == null || t(o.manualFilter);
+    }, i = (l) => {
+      n({ selected: l });
+    }, s = (l) => {
+      if (l !== null)
+        if ("includedValues" in l) {
+          const { includedValues: o, excludedValues: c, includeUnknownValues: m } = l;
+          if (!o || !c)
+            return;
+          n({
+            manualFilter: {
+              manuallySelected: o,
+              manuallyDeselected: c,
+              includeUnknownColumns: m
+            }
+          });
+        } else
+          n({ manualFilter: { manuallySelected: l } });
+    }, d = (l) => {
+      n({ patternFilter: { pattern: l } });
+    }, u = (l) => {
+      n({ mode: l.toUpperCase() });
+    }, b = (l, o) => {
+      n({ typeFilter: { selectedTypes: l, typeDisplays: o } });
+    }, w = (l) => {
+      n({ patternFilter: { isInverted: l } });
+    }, v = (l) => {
+      n({ patternFilter: { isCaseSensitive: l } });
+    }, { possibleValues: p } = X(
+      P(a, "control")
+    ), r = L([]), { selectedAndDeselected: T, setCurrentManualFilter: C } = ve({
+      data: h(() => a.control.data),
+      possibleValueIds: h(
+        () => {
+          var l;
+          return ((l = p.value) == null ? void 0 : l.map(({ id: o }) => o)) ?? null;
+        }
+      )
+    });
+    t = C;
+    const S = h(() => {
+      const { selected: l, deselected: o } = T.value;
+      return a.showUnknownValues ? {
+        includedValues: l,
+        excludedValues: o,
+        includeUnknownValues: a.control.data.manualFilter.includeUnknownColumns
+      } : l;
+    }), D = h(
+      () => T.value.selected === null ? J(te) : null
+    ), N = (l) => typeof l > "u" ? {} : l.reduce(
+      (o, { id: c, text: m }) => ({ ...o, [c]: m }),
+      {}
+    ), A = () => {
+      const l = a.control.data.typeFilter;
+      if (!l)
+        return [];
+      const o = l.selectedTypes, c = N(
+        l.typeDisplays
+      );
+      return o.map((m) => ({
+        id: m,
+        text: c[m] || m
+      }));
+    };
+    r.value = A();
+    const R = h(
+      () => {
+        var l, o;
+        return !!((o = (l = p.value) == null ? void 0 : l[0]) != null && o.hasOwnProperty("type"));
+      }
+    ), { excludedLabel: j, includedLabel: q } = Y(
+      P(a, "control")
+    ), E = h(() => j ?? a.twinlistLeftLabel), O = h(() => q ?? a.twinlistRightLabel);
+    return (l, o) => {
+      var c;
+      return f(), I(U(me), B(l.$attrs, {
+        id: l.labelForId,
+        disabled: l.disabled,
+        "with-types": R.value,
+        "selected-types": (c = l.control.data.typeFilter) == null ? void 0 : c.selectedTypes,
+        "additional-possible-types": r.value,
+        pattern: l.control.data.patternFilter.pattern,
+        mode: l.control.data.mode.toLowerCase(),
+        "case-sensitive-pattern": l.control.data.patternFilter.isCaseSensitive,
+        "empty-state-component": D.value,
+        "inverse-pattern": l.control.data.patternFilter.isInverted,
+        "manual-selection": S.value,
+        "include-unknown-values": l.control.data.manualFilter.includeUnknownColumns,
+        "mode-label": "Selection mode",
+        "possible-values": U(p) ?? [],
+        size: l.twinlistSize,
+        "left-label": E.value,
+        "right-label": O.value,
+        "is-valid": l.isValid,
+        compact: "",
+        "show-resize-handle": "",
+        "onUpdate:selected": i,
+        "onUpdate:manualSelection": s,
+        "onUpdate:pattern": d,
+        "onUpdate:mode": u,
+        "onUpdate:selectedTypes": b,
+        "onUpdate:inversePattern": w,
+        "onUpdate:caseSensitivePattern": v
+      }), null, 16, ["id", "disabled", "with-types", "selected-types", "additional-possible-types", "pattern", "mode", "case-sensitive-pattern", "empty-state-component", "inverse-pattern", "manual-selection", "include-unknown-values", "possible-values", "size", "left-label", "right-label", "is-valid"]);
+    };
+  }
+}), Ce = /* @__PURE__ */ z(ye, [["__scopeId", "data-v-52473411"]]);
+export {
+  Ce as default
+};

package/dist/{MultiselectListBox-D5smzcVZ.js → MultiselectListBox-BFQxtoyR.js}

@@ -1,6 +1,6 @@
 import { openBlock as h, createElementBlock as u, mergeProps as x, withModifiers as a, toDisplayString as y, toRef as p, watch as I, resolveComponent as v, normalizeClass as C, normalizeStyle as w, createElementVNode as f, withKeys as d, normalizeProps as V, guardReactiveProps as k, Fragment as H, renderList as B, createBlock as g, resolveDynamicComponent as D, createCommentVNode as b, createVNode as K } from "vue";
 import { b as N } from "./index-Bf0xDq3g.js";
-import { _ as S } from "./SettingsSubPanel.vue_vue_type_style_index_0_scoped_67b92e23_lang-dAvPWPee.js";
+import { _ as S } from "./SettingsSubPanel.vue_vue_type_style_index_0_scoped_67b92e23_lang-BM4d25sK.js";
 const A = (e, t) => {
   let i, n = 0;
   return (...r) => {

package/dist/{NameFilter-B9TOgIBA.js → NameFilter-BxfjNVu-.js}

@@ -1,5 +1,5 @@
 import { defineComponent as n, openBlock as o, createBlock as t, mergeProps as a } from "vue";
-import l from "./TwinlistControl-Dw5uSnOi.js";
+import l from "./MultimodeTwinlistControl-CV2v4Y5n.js";
 const u = /* @__PURE__ */ n({
   __name: "NameFilter",
   props: {

package/dist/{NumberControl-YCMcJfZB.js → NumberControl-Df91UAXl.js}

@@ -1,5 +1,5 @@
 import { defineComponent as o, openBlock as n, createBlock as t, mergeProps as r } from "vue";
-import { _ as a } from "./NumberControlBase.vue_vue_type_script_setup_true_lang-CPj9t6fL.js";
+import { _ as a } from "./NumberControlBase.vue_vue_type_script_setup_true_lang-DLqtcp04.js";
 const s = /* @__PURE__ */ o({
   __name: "NumberControl",
   props: {

package/dist/NumberControlBase.vue_vue_type_script_setup_true_lang-DLqtcp04.js

@@ -0,0 +1,53 @@
+import { defineComponent as v, computed as r, openBlock as V, createBlock as E, unref as f } from "vue";
+import { u as y } from "./useBuiltinValidations-8VwUv3RT.js";
+import { N as b } from "./NumberInput-BLlTeOig.js";
+const g = 1, h = 0.1, _ = /* @__PURE__ */ v({
+  __name: "NumberControlBase",
+  props: {
+    control: {},
+    handleChange: { type: Function },
+    changeValue: { type: Function },
+    disabled: { type: Boolean },
+    isValid: { type: Boolean },
+    onRegisterValidation: { type: Function },
+    labelForId: {},
+    type: {}
+  },
+  setup(d) {
+    const o = d, s = o.type === "integer" ? g : h, i = ({ min: e, isExclusive: n }) => (a) => isNaN(a) || (n ? a > e : a >= e), u = ({ max: e, isExclusive: n }) => (a) => isNaN(a) || (n ? a < e : a <= e), c = y(
+      {
+        min: i,
+        max: u
+      },
+      o
+    ), t = r(() => c.value.min), l = r(() => c.value.max), p = () => {
+      const e = o.control.data;
+      if (t.value && !i(t.value)(e)) {
+        const { min: n, isExclusive: a } = t.value;
+        a ? o.changeValue(n + s) : o.changeValue(n);
+      } else if (l.value && !u(l.value)(e)) {
+        const { max: n, isExclusive: a } = l.value;
+        a ? o.changeValue(n - s) : o.changeValue(n);
+      }
+    };
+    return (e, n) => {
+      var a, m;
+      return V(), E(f(b), {
+        id: e.labelForId,
+        class: "number-input",
+        disabled: e.disabled,
+        "model-value": e.control.data,
+        type: e.type,
+        min: (a = t.value) == null ? void 0 : a.min,
+        max: (m = l.value) == null ? void 0 : m.max,
+        "is-valid": e.isValid,
+        compact: "",
+        "onUpdate:modelValue": e.changeValue,
+        onFocusout: p
+      }, null, 8, ["id", "disabled", "model-value", "type", "min", "max", "is-valid", "onUpdate:modelValue"]);
+    };
+  }
+});
+export {
+  _
+};

package/dist/{NumberInput-DO8rNjya.js → NumberInput-BLlTeOig.js}

@@ -1,7 +1,7 @@
 import { A as p } from "./arrow-dropdown-DjUxzjqC.js";
 /* empty css                   */
 import { resolveComponent as h, openBlock as o, createElementBlock as d, normalizeClass as l, createElementVNode as n, createCommentVNode as f, withModifiers as r, createVNode as m } from "vue";
-import { _ as V } from "./SettingsSubPanel.vue_vue_type_style_index_0_scoped_67b92e23_lang-dAvPWPee.js";
+import { _ as V } from "./SettingsSubPanel.vue_vue_type_style_index_0_scoped_67b92e23_lang-BM4d25sK.js";
 const c = 200, g = 50, v = 0.1, E = 1, I = {
   name: "NumberInput",
   components: {

package/dist/OneOfDropdown-CLPbmMt7.js

@@ -0,0 +1,34 @@
+import { defineComponent as i, computed as u, openBlock as c, createBlock as m, unref as s } from "vue";
+import { o as b } from "./index-Blg1O3Fz.js";
+import { D as f } from "./Dropdown-D8qp_4wZ.js";
+const F = /* @__PURE__ */ i({
+  __name: "OneOfDropdown",
+  props: {
+    control: {},
+    handleChange: { type: Function },
+    changeValue: { type: Function },
+    disabled: { type: Boolean },
+    isValid: { type: Boolean },
+    onRegisterValidation: { type: Function },
+    labelForId: {}
+  },
+  setup(p) {
+    var l, n;
+    const e = p, r = ((n = (l = e.control.schema) == null ? void 0 : l.oneOf) == null ? void 0 : n.map(b)) ?? [], a = u({
+      get: () => e.control.data ?? "",
+      set: e.changeValue
+    });
+    return (o, t) => (c(), m(s(f), {
+      id: o.labelForId,
+      modelValue: a.value,
+      "onUpdate:modelValue": t[0] || (t[0] = (d) => a.value = d),
+      "possible-values": s(r),
+      ariaLabel: o.control.label,
+      disabled: o.disabled,
+      compact: ""
+    }, null, 8, ["id", "modelValue", "possible-values", "ariaLabel", "disabled"]));
+  }
+});
+export {
+  F as default
+};

package/dist/{RadioControl-DK_i_SC9.js → RadioControl-CDi8WbsE.js}

@@ -1,6 +1,6 @@
 import { defineComponent as e, openBlock as n, createBlock as t, mergeProps as a } from "vue";
-import { _ as r } from "./RadioControlBase.vue_vue_type_script_setup_true_lang-B_Dxf3fU.js";
-import { _ as p } from "./SettingsSubPanel.vue_vue_type_style_index_0_scoped_67b92e23_lang-dAvPWPee.js";
+import { _ as r } from "./RadioControlBase.vue_vue_type_script_setup_true_lang-B6clHvd5.js";
+import { _ as p } from "./SettingsSubPanel.vue_vue_type_style_index_0_scoped_67b92e23_lang-BM4d25sK.js";
 const i = /* @__PURE__ */ e({
   __name: "RadioControl",
   props: {

package/dist/{RadioControlBase.vue_vue_type_script_setup_true_lang-B_Dxf3fU.js → RadioControlBase.vue_vue_type_script_setup_true_lang-B6clHvd5.js}

@@ -1,7 +1,7 @@
 import { resolveComponent as c, openBlock as m, createBlock as p, normalizeClass as b, defineComponent as f, computed as s, ref as v, onMounted as B, resolveDynamicComponent as y, createCommentVNode as V } from "vue";
-import { o as h } from "./index-hm05O8UX.js";
-import { B as _, V as g } from "./ValueSwitch-CGXtJV-B.js";
-import { _ as C } from "./SettingsSubPanel.vue_vue_type_style_index_0_scoped_67b92e23_lang-dAvPWPee.js";
+import { o as h } from "./index-Blg1O3Fz.js";
+import { B as _, V as g } from "./ValueSwitch-BI5z5U3F.js";
+import { _ as C } from "./SettingsSubPanel.vue_vue_type_style_index_0_scoped_67b92e23_lang-BM4d25sK.js";
 const R = {
   name: "RadioButtons",
   components: {

package/dist/{RichTextControl-Bp6N-XYM.js → RichTextControl-YMNSyY3O.js}

@@ -2,16 +2,16 @@ import { defineComponent as be, ref as ee, computed as we, onMounted as An, watc
 import { a as Dd, c as Rd } from "./popper-CRR--9mA.js";
 import { i as Ua, g as qa } from "./navigator-DWmzYl-A.js";
 import { C as Ld } from "./close-h7XT0ja0.js";
-import { F as ao } from "./FunctionButton-BjutjqfY.js";
-import { _ as Xe, o as Qo } from "./SettingsSubPanel.vue_vue_type_style_index_0_scoped_67b92e23_lang-dAvPWPee.js";
-import { B as qi } from "./Button-B27OsWa6.js";
-import { I as Zo } from "./InputField-CWbS01h9.js";
+import { F as ao } from "./FunctionButton-Bo0NcfGh.js";
+import { _ as Xe, n as Qo } from "./SettingsSubPanel.vue_vue_type_style_index_0_scoped_67b92e23_lang-BM4d25sK.js";
+import { B as qi } from "./Button-DnQZFkaO.js";
+import { I as Zo } from "./InputField-DRLCzzDf.js";
 import { u as Ja, f as Ga, s as Ya, a as Xa } from "./floating-ui.vue-B-MrqKCT.js";
 import { o as Pd } from "./index-Bf0xDq3g.js";
 import { N as Bd } from "./arrow-next-Qa8PNb04.js";
 import { u as Fd } from "./useDropdownNavigation-D6ZenVxz.js";
-import { C as $d } from "./Checkbox-Bl3rvtXe.js";
-import { t as zd } from "./toString-DkbNkGT4.js";
+import { C as $d } from "./Checkbox-DB9YeQa-.js";
+import { t as zd } from "./toString-B9O7P854.js";
 const Hd = (n, e) => (n % e + e) % e;
 /*!
 * tabbable 6.2.0