@knime/jsonforms 1.12.0 → 1.12.1

package/dist/MultimodeTwinlistControl-DnpmvhFB.js

@@ -0,0 +1,469 @@
+import { openBlock as h, createElementBlock as M, createElementVNode as j, toRef as I, resolveComponent as m, normalizeClass as N, createBlock as w, withCtx as v, createVNode as f, createCommentVNode as V, mergeProps as _, defineComponent as O, ref as H, computed as c, markRaw as W, unref as L } from "vue";
+import { m as G } from "./index-Blg1O3Fz.js";
+import { u as J, a as K } from "./usePossibleValues-BB4he0jT.js";
+import { S as Q, a as X, u as Y, T as Z } from "./TwinlistLoadingInfo-Dcbz2hUN.js";
+import { u as $ } from "./MultimodeTwinlistControl.vue_vue_type_style_index_0_scoped_ca157254_lang-DjGJNwBV.js";
+import { f as P } from "./useSearch-hpyYQ_6y.js";
+import { C as ee } from "./Checkboxes-DNbu05C7.js";
+import { x as te, _ as U } from "./SectionHeading.vue_vue_type_style_index_0_scoped_625edfbe_lang-Dq3HWX2w.js";
+import { V as ae } from "./ValueSwitch-Ba0d4Jda.js";
+const le = {
+  xmlns: "http://www.w3.org/2000/svg",
+  fill: "none",
+  stroke: "#000",
+  "stroke-linejoin": "round",
+  viewBox: "0 0 32 32"
+};
+function ne(t, l) {
+  return h(), M("svg", le, l[0] || (l[0] = [
+    j("path", { d: "m13.31 27.81 5.11-3.19v-9.15L28.95 4.19H3.05l10.26 11.28z" }, null, -1)
+  ]));
+}
+const se = { render: ne }, ie = {
+  manual: "Manual",
+  wildcard: "Wildcard",
+  regex: "Regex",
+  type: "Type"
+}, oe = {
+  name: "MultiModeTwinlist",
+  components: {
+    Label: te,
+    FilterIcon: se,
+    SearchInput: Q,
+    Checkboxes: ee,
+    ValueSwitch: ae,
+    Twinlist: X
+  },
+  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(t) {
+    const { includedValues: l } = Y(
+      I(t, "manualSelection")
+    );
+    return { manuallySelected: l };
+  },
+  data() {
+    return {
+      invalidPossibleValueIds: /* @__PURE__ */ new Set()
+    };
+  },
+  computed: {
+    possibleValueIds() {
+      return this.possibleValues.map(({ id: t }) => t);
+    },
+    possibleTypes() {
+      const t = this.possibleValues.map(({ type: s }) => s).filter(Boolean), l = t.map((s) => s.id);
+      return [...this.additionalPossibleTypes.filter(
+        (s) => s && !l.includes(s.id)
+      ), ...t].filter((s) => s && s.id !== "").filter(
+        // remove duplicates
+        (s, i, b) => i === b.findIndex((r) => r.id === s.id && r.text === s.text)
+      );
+    },
+    matchingValueIds() {
+      return this.possibleValues.filter((t) => this.itemMatches(t)).map((t) => t.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 : P[this.mode].normalize(
+        this.mode === "type" ? this.selectedTypes : this.pattern,
+        this.caseSensitivePattern
+      );
+    },
+    possibleModes() {
+      let t = Object.entries(ie).map(([l, a]) => ({ id: l, text: a }));
+      return this.withTypes || (t = t.filter((l) => l.id !== "type")), t;
+    }
+  },
+  watch: {
+    selectedValues: {
+      immediate: !0,
+      handler(t, l) {
+        !l || t === null || (t.length !== l.length || l.some((a, o) => a !== t[o])) && this.$emit("update:selected", this.selectedValues);
+      }
+    }
+  },
+  methods: {
+    onManualInput(t) {
+      this.mode === "manual" && this.$emit("update:manualSelection", t);
+    },
+    onPatternInput(t) {
+      this.$emit("update:pattern", t);
+    },
+    onTypeInput(t) {
+      this.$emit("update:selectedTypes", t, this.possibleTypes);
+    },
+    onModeChange(t) {
+      this.$emit("update:mode", t);
+    },
+    onToggleCaseSensitivePattern(t) {
+      this.$emit("update:caseSensitivePattern", t);
+    },
+    onToggleInversePattern(t) {
+      this.$emit("update:inversePattern", t);
+    },
+    validate() {
+      return this.$refs.twinlist.validate();
+    },
+    hasSelection() {
+      var t;
+      return !!((t = this.selectedValues) != null && t.length);
+    },
+    itemMatches(t) {
+      var a;
+      return P[this.mode].test(
+        this.mode === "type" ? (a = t.type) == null ? void 0 : a.id : t.text,
+        this.normalizedSearchTerm,
+        this.caseSensitivePattern,
+        this.inversePattern
+      );
+    }
+  }
+};
+function de(t, l, a, o, s, i) {
+  const b = m("ValueSwitch"), r = m("Label"), g = m("FilterIcon"), T = m("SearchInput"), S = m("Checkboxes"), y = m("Twinlist");
+  return h(), M("div", {
+    class: N(["multi-mode-twinlist", { disabled: a.disabled }])
+  }, [
+    a.showMode ? (h(), w(r, {
+      key: 0,
+      active: a.withModeLabel,
+      text: a.modeLabel,
+      class: "label"
+    }, {
+      default: v(({ labelForId: p }) => [
+        f(b, {
+          id: p,
+          ref: "mode",
+          compact: a.compact,
+          "model-value": a.mode,
+          disabled: a.disabled,
+          "possible-values": i.possibleModes,
+          "onUpdate:modelValue": i.onModeChange
+        }, null, 8, ["id", "compact", "model-value", "disabled", "possible-values", "onUpdate:modelValue"])
+      ]),
+      _: 1
+    }, 8, ["active", "text"])) : V("", !0),
+    a.mode === "regex" || a.mode === "wildcard" ? (h(), w(r, {
+      key: 1,
+      active: a.withPatternLabel,
+      text: a.patternLabel,
+      class: "label"
+    }, {
+      default: v(({ labelForId: p }) => [
+        f(T, {
+          id: p,
+          ref: "search",
+          "model-value": a.pattern,
+          label: a.patternLabel,
+          "initial-case-sensitive-search": a.caseSensitivePattern,
+          "initial-inverse-search": a.inversePattern,
+          placeholder: "Pattern",
+          "show-case-sensitive-search-button": "",
+          "show-inverse-search-button": "",
+          disabled: a.disabled,
+          tooltips: {
+            inverseSearch: "Move matching to other side"
+          },
+          compact: a.compact,
+          "onUpdate:modelValue": i.onPatternInput,
+          onToggleCaseSensitiveSearch: i.onToggleCaseSensitivePattern,
+          onToggleInverseSearch: i.onToggleInversePattern
+        }, {
+          icon: v(() => [
+            f(g)
+          ]),
+          _: 2
+        }, 1032, ["id", "model-value", "label", "initial-case-sensitive-search", "initial-inverse-search", "disabled", "compact", "onUpdate:modelValue", "onToggleCaseSensitiveSearch", "onToggleInverseSearch"])
+      ]),
+      _: 1
+    }, 8, ["active", "text"])) : V("", !0),
+    a.mode === "type" && i.possibleTypes.length > 0 ? (h(), w(r, {
+      key: 2,
+      active: a.withTypesLabel,
+      text: a.typesLabel,
+      class: "label"
+    }, {
+      default: v(() => [
+        f(S, {
+          "model-value": a.selectedTypes,
+          "possible-values": i.possibleTypes,
+          disabled: a.disabled,
+          "onUpdate:modelValue": i.onTypeInput
+        }, null, 8, ["model-value", "possible-values", "disabled", "onUpdate:modelValue"])
+      ]),
+      _: 1
+    }, 8, ["active", "text"])) : V("", !0),
+    f(y, _(t.$attrs, {
+      ref: "twinlist",
+      disabled: i.selectionDisabled,
+      "show-search": a.mode === "manual" && a.showSearch,
+      "model-value": i.twinlistModelValue,
+      "possible-values": a.possibleValues,
+      compact: a.compact,
+      "onUpdate:modelValue": i.onManualInput
+    }), null, 16, ["disabled", "show-search", "model-value", "possible-values", "compact", "onUpdate:modelValue"])
+  ], 2);
+}
+const re = /* @__PURE__ */ U(oe, [["render", de], ["__scopeId", "data-v-e5a6658e"]]), ue = /* @__PURE__ */ O({
+  __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(t) {
+    const l = t;
+    let a;
+    const o = (e) => {
+      const n = G(l.control.data, e);
+      l.changeValue(n), a == null || a(n.manualFilter);
+    }, s = (e) => {
+      o({ selected: e });
+    }, i = (e) => {
+      if (e !== null)
+        if ("includedValues" in e) {
+          const { includedValues: n, excludedValues: d, includeUnknownValues: u } = e;
+          if (!n || !d)
+            return;
+          o({
+            manualFilter: {
+              manuallySelected: n,
+              manuallyDeselected: d,
+              includeUnknownColumns: u
+            }
+          });
+        } else
+          o({ manualFilter: { manuallySelected: e } });
+    }, b = (e) => {
+      o({ patternFilter: { pattern: e } });
+    }, r = (e) => {
+      o({ mode: e.toUpperCase() });
+    }, g = (e, n) => {
+      o({ typeFilter: { selectedTypes: e, typeDisplays: n } });
+    }, T = (e) => {
+      o({ patternFilter: { isInverted: e } });
+    }, S = (e) => {
+      o({ patternFilter: { isCaseSensitive: e } });
+    }, { possibleValues: y } = J(
+      I(l, "control")
+    ), p = H([]), { selectedAndDeselected: C, setCurrentManualFilter: k } = $({
+      data: c(() => l.control.data),
+      possibleValueIds: c(
+        () => {
+          var e;
+          return ((e = y.value) == null ? void 0 : e.map(({ id: n }) => n)) ?? null;
+        }
+      )
+    });
+    a = k;
+    const x = c(() => {
+      const { selected: e, deselected: n } = C.value;
+      return l.showUnknownValues ? {
+        includedValues: e,
+        excludedValues: n,
+        includeUnknownValues: l.control.data.manualFilter.includeUnknownColumns
+      } : e;
+    }), B = c(
+      () => C.value.selected === null ? W(Z) : null
+    ), F = (e) => typeof e > "u" ? {} : e.reduce(
+      (n, { id: d, text: u }) => ({ ...n, [d]: u }),
+      {}
+    ), z = () => {
+      const e = l.control.data.typeFilter;
+      if (!e)
+        return [];
+      const n = e.selectedTypes, d = F(
+        e.typeDisplays
+      );
+      return n.map((u) => ({
+        id: u,
+        text: d[u] || u
+      }));
+    };
+    p.value = z();
+    const D = c(
+      () => {
+        var e, n;
+        return !!((n = (e = y.value) == null ? void 0 : e[0]) != null && n.hasOwnProperty("type"));
+      }
+    ), { excludedLabel: R, includedLabel: A } = K(
+      I(l, "control")
+    ), q = c(() => R ?? l.twinlistLeftLabel), E = c(() => A ?? l.twinlistRightLabel);
+    return (e, n) => {
+      var d;
+      return h(), w(L(re), _(e.$attrs, {
+        id: e.labelForId,
+        disabled: e.disabled,
+        "with-types": D.value,
+        "selected-types": (d = e.control.data.typeFilter) == null ? void 0 : d.selectedTypes,
+        "additional-possible-types": p.value,
+        pattern: e.control.data.patternFilter.pattern,
+        mode: e.control.data.mode.toLowerCase(),
+        "case-sensitive-pattern": e.control.data.patternFilter.isCaseSensitive,
+        "empty-state-component": B.value,
+        "inverse-pattern": e.control.data.patternFilter.isInverted,
+        "manual-selection": x.value,
+        "include-unknown-values": e.control.data.manualFilter.includeUnknownColumns,
+        "mode-label": "Selection mode",
+        "possible-values": L(y) ?? [],
+        size: e.twinlistSize,
+        "left-label": q.value,
+        "right-label": E.value,
+        "is-valid": e.isValid,
+        compact: "",
+        "show-resize-handle": "",
+        "onUpdate:selected": s,
+        "onUpdate:manualSelection": i,
+        "onUpdate:pattern": b,
+        "onUpdate:mode": r,
+        "onUpdate:selectedTypes": g,
+        "onUpdate:inversePattern": T,
+        "onUpdate:caseSensitivePattern": S
+      }), 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"]);
+    };
+  }
+}), ge = /* @__PURE__ */ U(ue, [["__scopeId", "data-v-ca157254"]]);
+export {
+  ge as default
+};

package/dist/MultimodeTwinlistControl.vue_vue_type_style_index_0_scoped_ca157254_lang-DjGJNwBV.js

@@ -0,0 +1,65 @@
+import { ref as v, watch as m } from "vue";
+import { g as S, a as g } from "./index-Blg1O3Fz.js";
+import "./TwinlistLoadingInfo-Dcbz2hUN.js";
+const w = ({
+  knownValuesSide: s,
+  possibleValueIds: l,
+  unknownValuesSide: n
+}) => {
+  const t = new Set(s.previous), a = new Set(l), u = (e) => S(e, a);
+  n.setNext([
+    ...u(n.previous),
+    ...S(l, t)
+  ]), s.setNext([
+    ...u(s.previous),
+    ...g(l, t)
+  ]);
+}, F = ({
+  data: s,
+  possibleValueIds: l
+}) => {
+  const n = v({
+    selected: null,
+    deselected: null
+  }), t = v(null), a = (e) => {
+    t.value = e;
+  }, u = () => {
+    if (!t.value || !l.value)
+      return;
+    let e, o;
+    const { manuallyDeselected: f, manuallySelected: p, includeUnknownColumns: r } = t.value, i = {
+      previous: f,
+      setNext: (c) => {
+        e = c;
+      }
+    }, d = {
+      previous: p,
+      setNext: (c) => {
+        o = c;
+      }
+    }, y = r ? i : d, M = r ? d : i;
+    w({
+      possibleValueIds: l.value,
+      knownValuesSide: y,
+      unknownValuesSide: M
+    }), n.value = {
+      selected: o,
+      deselected: e
+    };
+  };
+  return m(
+    () => s.value.manualFilter,
+    (e) => {
+      Object.is(t.value, e) ? n.value = {
+        selected: e.manuallySelected,
+        deselected: e.manuallyDeselected
+      } : (t.value = e, u());
+    },
+    { immediate: !0 }
+  ), m(() => l.value, u, {
+    immediate: !0
+  }), { selectedAndDeselected: n, setCurrentManualFilter: a };
+};
+export {
+  F as u
+};

package/dist/{MultiselectListBox-1nfMHeks.js → MultiselectListBox-DMZvKZT2.js}

@@ -1,7 +1,7 @@
 import { useId as x, toRef as S, watch as y, resolveComponent as p, openBlock as h, createElementBlock as u, normalizeClass as I, normalizeStyle as C, createElementVNode as m, mergeProps as v, withKeys as a, withModifiers as d, normalizeProps as w, guardReactiveProps as V, Fragment as k, renderList as D, createBlock as g, resolveDynamicComponent as H, toDisplayString as B, createCommentVNode as b, createVNode as K } from "vue";
 import { b as N } from "./index-Bf0xDq3g.js";
-import { S as A } from "./StyledListItem-CGCkC79t.js";
-import { _ as L } from "./SectionHeading.vue_vue_type_style_index_0_scoped_625edfbe_lang-DHWwwUrR.js";
+import { S as A } from "./StyledListItem-DCmVSIus.js";
+import { _ as L } from "./SectionHeading.vue_vue_type_style_index_0_scoped_625edfbe_lang-Dq3HWX2w.js";
 const T = (e, t) => {
   let i, r = 0;
   return (...l) => {

package/dist/{NameFilter-CUdwbsjT.js → NameFilter-qYooMIRr.js}

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

package/dist/{NumberControl-DEGlKs0O.js → NumberControl-mAvpRa8P.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-C0B7QKut.js";
+import { _ as a } from "./NumberControlBase.vue_vue_type_script_setup_true_lang-DsYiLVc0.js";
 const s = /* @__PURE__ */ o({
   __name: "NumberControl",
   props: {

package/dist/{NumberControlBase.vue_vue_type_script_setup_true_lang-C0B7QKut.js → NumberControlBase.vue_vue_type_script_setup_true_lang-DsYiLVc0.js}

@@ -1,6 +1,6 @@
 import { defineComponent as v, computed as r, openBlock as V, createBlock as E, unref as f } from "vue";
-import { u as y } from "./useBuiltinValidations-bc9asSxB.js";
-import { N as b } from "./NumberInput-dE-KEe9u.js";
+import { u as y } from "./useBuiltinValidations-ChTFREt7.js";
+import { N as b } from "./NumberInput-DfYpYs35.js";
 const g = 1, h = 0.1, _ = /* @__PURE__ */ v({
   __name: "NumberControlBase",
   props: {

package/dist/{NumberInput-dE-KEe9u.js → NumberInput-DfYpYs35.js}

@@ -1,7 +1,7 @@
 import { A as p } from "./arrow-dropdown-DdgjzLAO.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 "./SectionHeading.vue_vue_type_style_index_0_scoped_625edfbe_lang-DHWwwUrR.js";
+import { _ as V } from "./SectionHeading.vue_vue_type_style_index_0_scoped_625edfbe_lang-Dq3HWX2w.js";
 const c = 200, g = 50, v = 0.1, E = 1, I = {
   name: "NumberInput",
   components: {

package/dist/{OneOfDropdown-BMcupih8.js → OneOfDropdown-Dx9oWy6Y.js}

@@ -1,6 +1,6 @@
 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-D6ytFIra.js";
+import { D as f } from "./Dropdown-Cp5fC5vt.js";
 const F = /* @__PURE__ */ i({
   __name: "OneOfDropdown",
   props: {

package/dist/{RadioControl-Cgm2SatI.js → RadioControl-C0sZejgk.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-n6oZHbxa.js";
-import { _ as p } from "./SectionHeading.vue_vue_type_style_index_0_scoped_625edfbe_lang-DHWwwUrR.js";
+import { _ as r } from "./RadioControlBase.vue_vue_type_script_setup_true_lang-BBZFZcBX.js";
+import { _ as p } from "./SectionHeading.vue_vue_type_style_index_0_scoped_625edfbe_lang-Dq3HWX2w.js";
 const i = /* @__PURE__ */ e({
   __name: "RadioControl",
   props: {

package/dist/{RadioControlBase.vue_vue_type_script_setup_true_lang-n6oZHbxa.js → RadioControlBase.vue_vue_type_script_setup_true_lang-BBZFZcBX.js}

@@ -1,8 +1,8 @@
 import { resolveComponent as b, openBlock as m, createBlock as p, normalizeClass as f, defineComponent as v, computed as n, ref as V, toRef as B, onMounted as h, resolveDynamicComponent as y, createCommentVNode as _ } from "vue";
 import { o as g } from "./index-Blg1O3Fz.js";
-import { u as C } from "./usePossibleValues-NHPCKPdi.js";
-import { B as R, V as O } from "./ValueSwitch-B-yL0b_A.js";
-import { _ as S } from "./SectionHeading.vue_vue_type_style_index_0_scoped_625edfbe_lang-DHWwwUrR.js";
+import { u as C } from "./usePossibleValues-BB4he0jT.js";
+import { B as R, V as O } from "./ValueSwitch-Ba0d4Jda.js";
+import { _ as S } from "./SectionHeading.vue_vue_type_style_index_0_scoped_625edfbe_lang-Dq3HWX2w.js";
 const F = {
   name: "RadioButtons",
   components: {

package/dist/{RichTextControl-YEul6CJZ.js → RichTextControl-ikOmp5Zc.js}

@@ -3,14 +3,14 @@ import { a as td, c as nd } from "./popper-CRR--9mA.js";
 import { i as Ca } from "./navigator-D_R-txCf.js";
 import { g as Ma } from "./hotkeys-kwHHtFKz.js";
 import { C as rd } from "./close-BuY4mhXV.js";
-import { _ as We, q as Ks, C as id, v as Bo } from "./SectionHeading.vue_vue_type_style_index_0_scoped_625edfbe_lang-DHWwwUrR.js";
+import { _ as We, r as Ks, C as id, x as Bo } from "./SectionHeading.vue_vue_type_style_index_0_scoped_625edfbe_lang-Dq3HWX2w.js";
 import { F as sd, u as od } from "./useDropdownNavigation-7o7SRJSo.js";
-import { B as Di } from "./Button-BU4AHIik.js";
-import { I as Fo } from "./InputField-D-drv5NW.js";
+import { B as Di } from "./Button-a3DyR88M.js";
+import { I as Fo } from "./InputField-B2bBpIrm.js";
 import { u as va, f as Ta, s as Ea, a as Oa } from "./floating-ui.vue-B-MrqKCT.js";
 import { o as ld } from "./index-Bf0xDq3g.js";
 import { N as ad } from "./arrow-next-CIOU5o42.js";
-import { t as cd } from "./toString-DfO6VEzj.js";
+import { t as cd } from "./toString-ByDUn5bZ.js";
 const ud = (n, e) => (n % e + e) % e, dd = me({
   name: "BaseModal",
   components: {

package/dist/{SectionHeading-HNpa-JMB.js → SectionHeading-DoKeahJG.js}

@@ -1,5 +1,5 @@
 import { defineComponent as o, openBlock as n, createElementBlock as s, createElementVNode as t, toDisplayString as r, renderSlot as i } from "vue";
-import { _ as c } from "./SectionHeading.vue_vue_type_style_index_0_scoped_625edfbe_lang-DHWwwUrR.js";
+import { _ as c } from "./SectionHeading.vue_vue_type_style_index_0_scoped_625edfbe_lang-Dq3HWX2w.js";
 const a = { class: "section-header" }, d = { class: "section-header-layout-container" }, _ = /* @__PURE__ */ o({
   __name: "SectionHeading",
   props: {