@bonsae/nrg 0.18.5 → 0.19.1

package/test/client/component/setup.js

@@ -1,24 +1,63 @@
-// src/test/client/component/setup.ts
-import { beforeEach } from "vitest";
-import { config } from "vitest-browser-vue";
-
-// src/test/client/mocks.ts
-function createRED() {
-  return {
-    _: (key) => key,
+import { beforeEach as z } from "vitest";
+import { config as O } from "vitest-browser-vue";
+import { defineComponent as V, openBlock as l, createElementBlock as c, normalizeClass as R, createCommentVNode as f, renderSlot as w, createTextVNode as D, toDisplayString as T, resolveComponent as g, createBlock as v, createElementVNode as m, shallowRef as q, withDirectives as H, vShow as J, Teleport as K, Fragment as _, renderList as L, createVNode as N } from "vue";
+function j() {
+  const e = {
+    get(t) {
+      return e[t];
+    },
+    set(t, n) {
+      return e[t] = n, n;
+    },
+    remove(t) {
+      const n = e[t];
+      return delete e[t], n;
+    }
+  };
+  return e;
+}
+function Y(e, t) {
+  if (e === t) return !0;
+  const n = e.split("/"), r = t.split("/");
+  for (let s = 0; s < n.length; s++) {
+    if (n[s] === "#") return !0;
+    if (s >= r.length || n[s] !== "+" && n[s] !== r[s]) return !1;
+  }
+  return n.length === r.length;
+}
+function Q(e) {
+  var t;
+  (t = e.__reset) == null || t.call(e);
+}
+function Z() {
+  const e = /* @__PURE__ */ new Map(), t = /* @__PURE__ */ new Map(), n = [], r = {}, s = [];
+  let d = !1, a = 0;
+  const h = () => {
+    const i = {
+      element: null,
+      open: () => i,
+      close: () => i,
+      setContent: () => i,
+      move: () => {
+      }
+    };
+    return i;
+  }, b = {
+    _: (i) => i,
     editor: {
-      createEditor(options) {
-        let currentValue = options.value || "";
-        const session = {
-          on(_event, _cb) {
+      createEditor(i) {
+        let u = (i == null ? void 0 : i.value) || "";
+        const y = {}, I = {
+          on(o, p) {
+            (y[o] ?? (y[o] = [])).push(p);
           }
         };
         return {
-          getValue: () => currentValue,
-          setValue: (val) => {
-            currentValue = val;
+          getValue: () => u,
+          setValue: (o) => {
+            u = o, (y.change ?? []).forEach((p) => p());
           },
-          getSession: () => session,
+          getSession: () => I,
           focus: () => {
           },
           destroy: () => {
@@ -31,7 +70,7 @@ function createRED() {
       },
       prepareConfigNodeSelect: () => {
       },
-      validateNode: () => true
+      validateNode: () => !0
     },
     tray: {
       show: () => {
@@ -40,162 +79,1532 @@ function createRED() {
       }
     },
     popover: {
-      tooltip: () => ({ delete: () => {
-      }, setAction: () => {
-      } })
+      create: () => h(),
+      tooltip: () => {
+        const i = {
+          element: null,
+          open: () => i,
+          close: () => i,
+          setContent: () => i,
+          move: () => {
+          },
+          delete: () => {
+          },
+          setAction: () => {
+          }
+        };
+        return i;
+      }
     },
     nodes: {
-      registerType: () => {
+      registerType(i, u) {
+        t.set(i, u);
+      },
+      getType(i) {
+        return t.get(i) ?? null;
+      },
+      node(i) {
+        return e.get(i) ?? null;
+      },
+      add(i) {
+        return e.set(i.id, i), i;
+      },
+      remove(i) {
+        const u = e.get(i);
+        return e.delete(i), { links: [], nodes: u ? [u] : [] };
+      },
+      clear() {
+        e.clear();
+      },
+      // The mock keeps a single registry: eachNode and eachConfig iterate the
+      // same entries. Register whatever your component expects to find.
+      eachNode(i) {
+        for (const u of e.values())
+          if (i(u) === !1) break;
+      },
+      eachConfig(i) {
+        for (const u of e.values())
+          if (i(u) === !1) break;
       },
-      node: () => null,
-      dirty: () => false
+      filterNodes(i) {
+        return [...e.values()].filter(
+          (u) => (i.type === void 0 || u.type === i.type) && (i.z === void 0 || u.z === i.z)
+        );
+      },
+      filterLinks(i) {
+        return n.filter(
+          (u) => {
+            var y, I, o, p;
+            return (i.source === void 0 || u.source === i.source || ((y = u.source) == null ? void 0 : y.id) === ((I = i.source) == null ? void 0 : I.id)) && (i.target === void 0 || u.target === i.target || ((o = u.target) == null ? void 0 : o.id) === ((p = i.target) == null ? void 0 : p.id));
+          }
+        );
+      },
+      addLink(i) {
+        n.push(i);
+      },
+      dirty(i) {
+        if (i === void 0) return d;
+        d = i;
+      },
+      id() {
+        return (++a).toString(16).padStart(16, "0");
+      }
     },
     events: {
-      on: () => {
+      on(i, u) {
+        (r[i] ?? (r[i] = [])).push(u);
       },
-      off: () => {
+      off(i, u) {
+        r[i] && (u ? r[i] = r[i].filter(
+          (y) => y !== u
+        ) : delete r[i]);
       },
-      emit: () => {
+      emit(i, ...u) {
+        [...r[i] ?? []].forEach((y) => y(...u));
       }
     },
-    settings: {},
-    notify: () => {
-    }
+    comms: {
+      subscribe(i, u) {
+        s.push({ topic: i, callback: u });
+      },
+      unsubscribe(i, u) {
+        const y = s.findIndex(
+          (I) => I.topic === i && I.callback === u
+        );
+        y !== -1 && s.splice(y, 1);
+      },
+      publish(i, u) {
+        [...s].filter((y) => Y(y.topic, i)).forEach((y) => y.callback(i, u));
+      }
+    },
+    settings: j(),
+    notify: () => ({
+      update: () => {
+      },
+      close: () => {
+      }
+    })
   };
+  return Object.defineProperty(b, "__reset", {
+    enumerable: !1,
+    value: () => {
+      e.clear(), t.clear(), n.length = 0;
+      for (const i of Object.keys(r))
+        delete r[i];
+      s.length = 0, d = !1, b.settings = j();
+    }
+  }), b;
 }
-function ensureState(el) {
-  if (el && !el.__jqState) {
-    el.__jqState = {
-      typedInput: { value: "", type: "" },
-      listeners: {}
-    };
-  }
-  return el ? el.__jqState : { typedInput: { value: "", type: "" }, listeners: {} };
-}
-function createJQ(el) {
-  const state = ensureState(el);
-  const jq = {
-    0: el,
-    length: el ? 1 : 0,
-    typedInput(action, value) {
-      if (typeof action === "object") {
-        state.typedInput = { value: "", type: action.default || "" };
-        return jq;
-      }
-      if (action === "value") {
-        if (value !== void 0) {
-          state.typedInput.value = String(value);
-          if (el) el.setAttribute("value", String(value));
-          return void 0;
+function G(e) {
+  return e && !e.__jqState && (e.__jqState = {
+    typedInput: { value: "", type: "" },
+    listeners: {}
+  }), e ? e.__jqState : { typedInput: { value: "", type: "" }, listeners: {} };
+}
+function S(e) {
+  const t = G(e), n = {
+    0: e,
+    length: e ? 1 : 0,
+    typedInput(r, s) {
+      if (typeof r == "object")
+        return t.typedInput = {
+          value: "",
+          type: r.default || "",
+          types: r.types
+        }, n;
+      if (r === "value") {
+        if (s !== void 0) {
+          t.typedInput.value = String(s), e && e.setAttribute("value", String(s));
+          return;
         }
-        return state.typedInput.value;
+        return t.typedInput.value;
       }
-      if (action === "type") {
-        if (value !== void 0) {
-          state.typedInput.type = String(value);
-          return void 0;
+      if (r === "type") {
+        if (s !== void 0) {
+          t.typedInput.type = String(s);
+          return;
         }
-        return state.typedInput.type;
+        return t.typedInput.type;
       }
-      return jq;
-    },
-    on(event, cb) {
-      if (!state.listeners[event]) state.listeners[event] = [];
-      state.listeners[event].push(cb);
-      return jq;
-    },
-    off(event) {
-      if (event) {
-        delete state.listeners[event];
-      } else {
-        for (const key of Object.keys(state.listeners)) {
-          delete state.listeners[key];
-        }
+      if (r === "types") {
+        t.typedInput.types = s;
+        return;
       }
-      return jq;
-    },
-    val(value) {
-      if (value !== void 0) {
-        if (el instanceof HTMLInputElement || el instanceof HTMLSelectElement || el instanceof HTMLTextAreaElement) {
-          el.value = String(value);
-        }
-        return jq;
+      if (r === "validate")
+        return !0;
+      if (r === "disable") {
+        t.typedInput.disabled = s !== !1;
+        return;
+      }
+      if (r === "enable") {
+        t.typedInput.disabled = !1;
+        return;
+      }
+      if (r === "hide") {
+        t.typedInput.hidden = !0;
+        return;
       }
-      if (el instanceof HTMLInputElement || el instanceof HTMLSelectElement || el instanceof HTMLTextAreaElement) {
-        return el.value;
+      if (r === "show") {
+        t.typedInput.hidden = !1;
+        return;
       }
-      return "";
+      if (r === "width") {
+        t.typedInput.width = s;
+        return;
+      }
+      if (r !== "focus")
+        return n;
+    },
+    on(r, s) {
+      return t.listeners[r] || (t.listeners[r] = []), t.listeners[r].push(s), n;
+    },
+    off(r) {
+      if (r)
+        delete t.listeners[r];
+      else
+        for (const s of Object.keys(t.listeners))
+          delete t.listeners[s];
+      return n;
     },
-    find(selector) {
-      return createJQ(el?.querySelector(selector) ?? null);
+    val(r) {
+      return r !== void 0 ? ((e instanceof HTMLInputElement || e instanceof HTMLSelectElement || e instanceof HTMLTextAreaElement) && (e.value = String(r)), n) : e instanceof HTMLInputElement || e instanceof HTMLSelectElement || e instanceof HTMLTextAreaElement ? e.value : "";
     },
-    append(child) {
-      const childEl = child?.[0] || child;
-      if (el && childEl instanceof Element) el.appendChild(childEl);
-      return jq;
+    find(r) {
+      return S((e == null ? void 0 : e.querySelector(r)) ?? null);
     },
-    appendTo(target) {
-      const t = target?.[0] || target;
-      if (t instanceof Element && el) t.appendChild(el);
-      return jq;
+    append(r) {
+      const s = (r == null ? void 0 : r[0]) || r;
+      return e && s instanceof Element && e.appendChild(s), n;
     },
-    html(content) {
-      if (el) el.innerHTML = content;
-      return jq;
+    appendTo(r) {
+      const s = (r == null ? void 0 : r[0]) || r;
+      return s instanceof Element && e && s.appendChild(e), n;
+    },
+    html(r) {
+      return e && (e.innerHTML = r), n;
     },
     empty() {
-      if (el) el.innerHTML = "";
-      return jq;
+      return e && (e.innerHTML = ""), n;
     },
     i18n() {
-      return jq;
+      return n;
     },
-    addClass(cls) {
-      el?.classList.add(cls);
-      return jq;
+    addClass(r) {
+      return e == null || e.classList.add(r), n;
     },
-    removeClass(cls) {
-      el?.classList.remove(cls);
-      return jq;
+    removeClass(r) {
+      return e == null || e.classList.remove(r), n;
     },
-    __trigger(event) {
-      (state.listeners[event] || []).forEach((cb) => cb());
+    __trigger(r) {
+      (t.listeners[r] || []).forEach((s) => s());
     }
   };
-  return jq;
-}
-function createJQuery() {
-  return function $(selector, attrs) {
-    if (typeof selector === "string") {
-      if (selector.trim().startsWith("<")) {
-        const tpl = document.createElement("template");
-        tpl.innerHTML = selector.trim();
-        const el = tpl.content.firstElementChild;
-        if (el && attrs) {
-          for (const [key, value] of Object.entries(attrs)) {
-            if (key === "html") {
-              el.innerHTML = String(value);
-            } else {
-              el.setAttribute(key, String(value));
-            }
-          }
-        }
-        return createJQ(el);
+  return n;
+}
+function X() {
+  return function(t, n) {
+    if (typeof t == "string") {
+      if (t.trim().startsWith("<")) {
+        const r = document.createElement("template");
+        r.innerHTML = t.trim();
+        const s = r.content.firstElementChild;
+        if (s && n)
+          for (const [d, a] of Object.entries(n))
+            d === "html" ? s.innerHTML = String(a) : s.setAttribute(d, String(a));
+        return S(s);
       }
-      return createJQ(document.querySelector(selector));
+      return S(document.querySelector(t));
     }
-    if (selector instanceof Element) return createJQ(selector);
-    if (selector && typeof selector === "object" && selector.nodeType)
-      return createJQ(selector);
-    return createJQ(null);
+    return t instanceof Element || t && typeof t == "object" && t.nodeType ? S(t) : S(null);
   };
 }
-
-// src/test/client/component/setup.ts
-config.global.mocks.$i18n = (key) => key;
-var RED = createRED();
-window.$ = createJQuery();
-window.RED = RED;
-beforeEach(() => {
-  RED.settings = {};
+const x = V({
+  name: "NodeRedInputLabel",
+  props: {
+    label: {
+      type: String,
+      default: ""
+    },
+    icon: {
+      type: String,
+      default: ""
+    },
+    required: {
+      type: Boolean,
+      default: !1
+    }
+  },
+  computed: {
+    iconClass() {
+      return this.icon ? `fa ${this.icon.startsWith("fa-") ? this.icon : `fa-${this.icon}`}` : "";
+    }
+  }
+}), E = (e, t) => {
+  const n = e.__vccOpts || e;
+  for (const [r, s] of t)
+    n[r] = s;
+  return n;
+}, ee = { class: "nrg-label" }, te = {
+  key: 1,
+  class: "nrg-required"
+};
+function ne(e, t, n, r, s, d) {
+  return l(), c("span", ee, [
+    e.icon ? (l(), c(
+      "i",
+      {
+        key: 0,
+        class: R(e.iconClass)
+      },
+      null,
+      2
+      /* CLASS */
+    )) : f("v-if", !0),
+    w(e.$slots, "default", {}, () => [
+      D(
+        T(e.label),
+        1
+        /* TEXT */
+      )
+    ], !0),
+    e.required ? (l(), c("span", te, "*")) : f("v-if", !0)
+  ]);
+}
+const k = /* @__PURE__ */ E(x, [["render", ne], ["__scopeId", "data-v-864b02f2"]]), C = "*************", re = V({
+  components: { NodeRedInputLabel: k },
+  props: {
+    modelValue: {
+      type: [String, Number],
+      default: void 0
+    },
+    value: {
+      type: [String, Number],
+      default: ""
+    },
+    type: {
+      type: String,
+      default: "text"
+    },
+    placeholder: {
+      type: String,
+      default: ""
+    },
+    label: {
+      type: String,
+      default: ""
+    },
+    icon: {
+      type: String,
+      default: ""
+    },
+    required: {
+      type: Boolean,
+      default: !1
+    },
+    error: {
+      type: String,
+      default: ""
+    }
+  },
+  emits: ["update:modelValue", "update:value", "input"],
+  data() {
+    return {
+      internalValue: ""
+    };
+  },
+  computed: {
+    effectiveValue() {
+      return this.modelValue !== void 0 ? this.modelValue : this.value;
+    }
+  },
+  beforeMount() {
+    this.internalValue = this.effectiveValue, this.onBlur();
+  },
+  methods: {
+    onInput(e) {
+      this.internalValue = e.target.value, this.$emit("update:modelValue", this.internalValue), this.$emit("update:value", this.internalValue), this.$emit("input", this.internalValue);
+    },
+    onFocus() {
+      this.type === "password" && this.internalValue === C && (this.internalValue = "");
+    },
+    onBlur() {
+      this.type === "password" && this.effectiveValue === "__PWD__" && (this.internalValue = C);
+    }
+  }
+}), oe = { style: { display: "flex", "flex-direction": "column", width: "100%" } }, ie = ["type", "value", "placeholder"], se = {
+  key: 0,
+  class: "node-red-vue-input-error-message"
+};
+function ae(e, t, n, r, s, d) {
+  const a = g("NodeRedInputLabel");
+  return l(), c("div", oe, [
+    w(e.$slots, "label", {}, () => [
+      e.label ? (l(), v(a, {
+        key: 0,
+        label: e.label,
+        icon: e.icon,
+        required: e.required
+      }, null, 8, ["label", "icon", "required"])) : f("v-if", !0)
+    ]),
+    m("input", {
+      ref: "inputField",
+      type: e.type,
+      value: e.internalValue,
+      placeholder: e.placeholder,
+      style: { width: "100%" },
+      onInput: t[0] || (t[0] = (...h) => e.onInput && e.onInput(...h)),
+      onFocus: t[1] || (t[1] = (...h) => e.onFocus && e.onFocus(...h)),
+      onBlur: t[2] || (t[2] = (...h) => e.onBlur && e.onBlur(...h))
+    }, null, 40, ie),
+    e.error ? (l(), c(
+      "div",
+      se,
+      T(e.error),
+      1
+      /* TEXT */
+    )) : f("v-if", !0)
+  ]);
+}
+const W = /* @__PURE__ */ E(re, [["render", ae]]), le = [
+  "msg",
+  "flow",
+  "global",
+  "str",
+  "num",
+  "bool",
+  "json",
+  "bin",
+  "re",
+  "jsonata",
+  "date",
+  "env",
+  "node",
+  "cred"
+], ue = ["errorPort", "completePort", "statusPort"], de = V({
+  components: { NodeRedInputLabel: k },
+  props: {
+    modelValue: {
+      type: Object,
+      default: void 0,
+      validator: function(e) {
+        if (e === void 0) return !0;
+        if (typeof e != "object" || e === null)
+          return console.warn(
+            "[WARN] Invalid modelValue for TypedInput. It must be an object."
+          ), !1;
+        const t = typeof e.value == "string" && typeof e.type == "string";
+        return t || console.warn(
+          "[WARN] Invalid modelValue for TypedInput. It must be an object with 'value' and 'type' properties being strings.",
+          e
+        ), t;
+      }
+    },
+    value: {
+      type: Object,
+      default: void 0,
+      validator: function(e) {
+        if (e === void 0) return !0;
+        if (typeof e != "object" || e === null)
+          return console.warn(
+            "[WARN] Invalid value for TypedInput. It must be an object."
+          ), !1;
+        const t = typeof e.value == "string" && typeof e.type == "string";
+        return t || console.warn(
+          "[WARN] Invalid value for TypedInput. It must be an object with 'value' and 'type' properties being strings.",
+          e
+        ), t;
+      }
+    },
+    types: {
+      type: Array,
+      default: () => le
+    },
+    label: {
+      type: String,
+      default: ""
+    },
+    icon: {
+      type: String,
+      default: ""
+    },
+    required: {
+      type: Boolean,
+      default: !1
+    },
+    error: {
+      type: String,
+      default: ""
+    }
+  },
+  emits: ["update:modelValue", "update:value"],
+  setup() {
+    return {
+      inputWidget: q(null),
+      mutationObserver: q(null)
+    };
+  },
+  computed: {
+    effectiveValue() {
+      return this.modelValue !== void 0 ? this.modelValue : this.value;
+    },
+    isProvidedValueTypeValid() {
+      const e = this.effectiveValue.type;
+      return this.types.includes(e);
+    }
+  },
+  watch: {
+    isProvidedValueTypeValid: {
+      handler(e) {
+        e || console.warn(
+          `Validation failed: type (${this.effectiveValue.type}) must be one of the provided types (${this.types}).`
+        );
+      },
+      immediate: !0
+    },
+    error(e) {
+      this.$nextTick(() => {
+        const t = this.$el.querySelector(
+          ".red-ui-typedInput-container"
+        );
+        t && (e ? t.classList.add("input-error") : t.classList.remove("input-error"));
+      });
+    }
+  },
+  mounted() {
+    const e = this.$refs.typedInput;
+    this.inputWidget = $(e), this.inputWidget.typedInput({
+      default: this.effectiveValue.type || this.types[0],
+      types: this.types
+    }), this.inputWidget.typedInput("value", this.effectiveValue.value || ""), this.inputWidget.typedInput(
+      "type",
+      this.effectiveValue.type || this.types[0]
+    ), this.$nextTick(() => {
+      const t = new MutationObserver((n) => {
+        for (const r of n)
+          r.attributeName === "value" && this.onChange();
+      });
+      t.observe(e, {
+        attributes: !0,
+        attributeFilter: ["value"]
+      }), this.mutationObserver = t;
+    }), this.inputWidget.on("change", () => {
+      this.onChange();
+    });
+  },
+  beforeUnmount() {
+    this.mutationObserver && (this.mutationObserver.disconnect(), this.mutationObserver = null);
+  },
+  methods: {
+    onChange() {
+      const e = this.inputWidget.typedInput("value"), t = this.inputWidget.typedInput("type");
+      if (this.effectiveValue.value !== e || this.effectiveValue.type !== t) {
+        const n = { value: e, type: t };
+        this.$emit("update:modelValue", n), this.$emit("update:value", n);
+      }
+    }
+  }
+}), pe = { style: { display: "flex", "flex-direction": "column", width: "100%" } }, ce = {
+  ref: "typedInput",
+  type: "text",
+  class: "node-red-typed-input",
+  style: { flex: "1", width: "100%" }
+}, ye = {
+  key: 0,
+  class: "node-red-vue-input-error-message"
+};
+function fe(e, t, n, r, s, d) {
+  const a = g("NodeRedInputLabel");
+  return l(), c("div", pe, [
+    w(e.$slots, "label", {}, () => [
+      e.label ? (l(), v(a, {
+        key: 0,
+        label: e.label,
+        icon: e.icon,
+        required: e.required
+      }, null, 8, ["label", "icon", "required"])) : f("v-if", !0)
+    ]),
+    m(
+      "input",
+      ce,
+      null,
+      512
+      /* NEED_PATCH */
+    ),
+    e.error ? (l(), c(
+      "div",
+      ye,
+      T(e.error),
+      1
+      /* TEXT */
+    )) : f("v-if", !0)
+  ]);
+}
+const B = /* @__PURE__ */ E(de, [["render", fe]]), me = V({
+  components: { NodeRedInputLabel: k },
+  props: {
+    modelValue: {
+      type: String,
+      default: void 0
+    },
+    value: {
+      type: String,
+      default: ""
+    },
+    type: {
+      type: String,
+      required: !0
+    },
+    node: {
+      type: Object,
+      required: !0
+    },
+    propName: {
+      type: String,
+      required: !0
+    },
+    label: {
+      type: String,
+      default: ""
+    },
+    icon: {
+      type: String,
+      default: ""
+    },
+    required: {
+      type: Boolean,
+      default: !1
+    },
+    error: {
+      type: String,
+      default: ""
+    }
+  },
+  emits: ["update:modelValue", "update:value"],
+  setup() {
+    return {
+      jqInput: q(null)
+    };
+  },
+  computed: {
+    inputId() {
+      return "node-input-" + this.propName;
+    },
+    effectiveValue() {
+      return this.modelValue !== void 0 ? this.modelValue : this.value;
+    }
+  },
+  mounted() {
+    RED.editor.prepareConfigNodeSelect(
+      this.node,
+      this.propName,
+      this.type,
+      "node-input"
+    );
+    const e = $("#" + this.inputId);
+    this.jqInput = e, e.on("change", () => {
+      const t = e.val(), n = t === "_ADD_" ? "" : t;
+      this.$emit("update:modelValue", n), this.$emit("update:value", n);
+    }), e.val(this.effectiveValue || "_ADD_");
+  },
+  beforeUnmount() {
+    this.jqInput && (this.jqInput.off("change"), this.jqInput = null);
+  }
+}), he = { style: { display: "flex", "flex-direction": "column", width: "100%" } }, ge = ["id"], ve = {
+  key: 0,
+  class: "node-red-vue-input-error-message"
+};
+function be(e, t, n, r, s, d) {
+  const a = g("NodeRedInputLabel");
+  return l(), c("div", he, [
+    w(e.$slots, "label", {}, () => [
+      e.label ? (l(), v(a, {
+        key: 0,
+        label: e.label,
+        icon: e.icon,
+        required: e.required
+      }, null, 8, ["label", "icon", "required"])) : f("v-if", !0)
+    ]),
+    m("input", {
+      id: e.inputId,
+      type: "text",
+      style: { width: "100%" }
+    }, null, 8, ge),
+    e.error ? (l(), c(
+      "div",
+      ve,
+      T(e.error),
+      1
+      /* TEXT */
+    )) : f("v-if", !0)
+  ]);
+}
+const U = /* @__PURE__ */ E(me, [["render", be]]), $e = V({
+  components: { NodeRedInputLabel: k },
+  props: {
+    modelValue: {
+      type: [String, Array],
+      default: void 0
+    },
+    value: {
+      type: [String, Array],
+      default: () => ""
+    },
+    options: {
+      type: Array,
+      required: !0,
+      validator: function(e) {
+        if (!Array.isArray(e))
+          return console.warn(
+            "[WARN] Invalid value for 'options' property. It must be an array."
+          ), !1;
+        const t = e.every(
+          (n) => typeof n == "object" && n !== null && typeof n.value == "string" && typeof n.label == "string" && Object.prototype.hasOwnProperty.call(n, "value") && Object.prototype.hasOwnProperty.call(n, "label")
+        );
+        return t || console.warn(
+          "[WARN] Invalid value for 'options' property. Each item must be an object with 'value' and 'label' properties being strings.",
+          e
+        ), t;
+      }
+    },
+    multiple: {
+      type: Boolean,
+      default: !1
+    },
+    label: {
+      type: String,
+      default: ""
+    },
+    icon: {
+      type: String,
+      default: ""
+    },
+    required: {
+      type: Boolean,
+      default: !1
+    },
+    error: {
+      type: String,
+      default: ""
+    }
+  },
+  emits: ["update:modelValue", "update:value"],
+  setup() {
+    return {
+      selectWidget: q(null)
+    };
+  },
+  computed: {
+    effectiveValue() {
+      return this.modelValue !== void 0 ? this.modelValue : this.value;
+    }
+  },
+  mounted() {
+    const e = this.$refs.selectInput, t = $(e);
+    this.selectWidget = t, t.typedInput({
+      types: [
+        {
+          multiple: this.multiple,
+          options: this.options
+        }
+      ]
+    }), t.typedInput(
+      "value",
+      Array.isArray(this.effectiveValue) ? this.effectiveValue.join(",") : this.effectiveValue
+    ), t.on("change", () => {
+      var r;
+      const n = this.multiple ? ((r = t.typedInput("value")) == null ? void 0 : r.split(",").filter(Boolean)) ?? [] : t.typedInput("value");
+      this.$emit("update:modelValue", n), this.$emit("update:value", n);
+    });
+  },
+  beforeUnmount() {
+    this.selectWidget && (this.selectWidget.off("change"), this.selectWidget = null);
+  }
+}), Ie = { style: { display: "flex", "flex-direction": "column", width: "100%" } }, Ve = {
+  ref: "selectInput",
+  type: "text",
+  class: "node-input-select",
+  style: { width: "100%" }
+}, Te = {
+  key: 0,
+  class: "node-red-vue-input-error-message"
+};
+function Ee(e, t, n, r, s, d) {
+  const a = g("NodeRedInputLabel");
+  return l(), c("div", Ie, [
+    w(e.$slots, "label", {}, () => [
+      e.label ? (l(), v(a, {
+        key: 0,
+        label: e.label,
+        icon: e.icon,
+        required: e.required
+      }, null, 8, ["label", "icon", "required"])) : f("v-if", !0)
+    ]),
+    m(
+      "input",
+      Ve,
+      null,
+      512
+      /* NEED_PATCH */
+    ),
+    e.error ? (l(), c(
+      "div",
+      Te,
+      T(e.error),
+      1
+      /* TEXT */
+    )) : f("v-if", !0)
+  ]);
+}
+const F = /* @__PURE__ */ E($e, [["render", Ee]]), we = V({
+  components: { NodeRedInputLabel: k },
+  props: {
+    modelValue: {
+      type: String,
+      default: void 0
+    },
+    value: {
+      type: String,
+      default: ""
+    },
+    language: {
+      type: String,
+      default: "json",
+      validator: function(e) {
+        const t = [
+          "abap",
+          "apex",
+          "azcli",
+          "bat",
+          "bicep",
+          "cameligo",
+          "clojure",
+          "coffee",
+          "cpp",
+          "csharp",
+          "csp",
+          "css",
+          "cypher",
+          "dart",
+          "dockerfile",
+          "ecl",
+          "elixir",
+          "flow9",
+          "freemarker2",
+          "fsharp",
+          "go",
+          "graphql",
+          "handlebars",
+          "hcl",
+          "html",
+          "ini",
+          "java",
+          "javascript",
+          "json",
+          "julia",
+          "kotlin",
+          "less",
+          "lexon",
+          "liquid",
+          "lua",
+          "m3",
+          "markdown",
+          "mdx",
+          "mips",
+          "msdax",
+          "mysql",
+          "objective-c",
+          "pascal",
+          "pascaligo",
+          "perl",
+          "pgsql",
+          "php",
+          "pla",
+          "postiats",
+          "powerquery",
+          "powershell",
+          "protobuf",
+          "pub",
+          "python",
+          "qsharp",
+          "r",
+          "razor",
+          "redis",
+          "redshift",
+          "restructuredtext",
+          "ruby",
+          "rust",
+          "sb",
+          "scala",
+          "scheme",
+          "scss",
+          "shell",
+          "solidity",
+          "sophia",
+          "sparql",
+          "sql",
+          "st",
+          "swift",
+          "systemverilog",
+          "tcl",
+          "twig",
+          "typescript",
+          "typespec",
+          "vb",
+          "wgsl",
+          "xml",
+          "yaml"
+        ], n = t.includes(e);
+        return n || console.warn(
+          `[WARN]: Invalid value for 'type' property: "${e}". Expected one of: ${t.join(", ")}`
+        ), n;
+      }
+    },
+    label: {
+      type: String,
+      default: ""
+    },
+    icon: {
+      type: String,
+      default: ""
+    },
+    required: {
+      type: Boolean,
+      default: !1
+    },
+    error: {
+      type: String,
+      default: ""
+    }
+  },
+  emits: [
+    "update:modelValue",
+    "update:value",
+    "editor-ready",
+    "tray-open",
+    "tray-close"
+  ],
+  setup() {
+    return {
+      // NOTE: must not be named "editor" — the template's ref="editor" would
+      // overwrite this with the DOM element on every re-render.
+      editorInstance: q(null),
+      expandedEditorTray: q(null)
+    };
+  },
+  data() {
+    const e = Math.random().toString(36).substring(2, 9);
+    return {
+      editorId: "node-red-editor-" + e,
+      stateId: e,
+      trayElement: null
+    };
+  },
+  computed: {
+    effectiveValue() {
+      return this.modelValue !== void 0 ? this.modelValue : this.value;
+    }
+  },
+  mounted() {
+    const e = $(this.$refs["expand-button"]);
+    RED.popover.tooltip(e, RED._("node-red:common.label.expand")), this.mountEditor(), this.createExpandeEditorTray();
+  },
+  beforeUnmount() {
+    if (this.editorInstance) {
+      try {
+        this.editorInstance.destroy();
+      } catch (e) {
+        console.error(`Error destroying editor for ID ${this.editorId}:`, e);
+      }
+      this.editorInstance = null;
+    }
+  },
+  methods: {
+    mountEditor() {
+      this.$nextTick(() => {
+        const e = this.$refs.container, t = this.$refs.editor;
+        if (e && t)
+          try {
+            const n = e.style.height, r = e.style.width;
+            n ? t.style.height = n : t.style.height = "200px", r ? t.style.width = r : t.style.width = "100%", this.createEditorInstance();
+          } catch (n) {
+            console.error(
+              "[NodeRedEditorInput] Error setting initial editor style:",
+              n
+            ), this.createEditorInstance();
+          }
+        else
+          console.error(
+            "[NodeRedEditorInput] Container or Editor div refs not found on mount."
+          );
+      });
+    },
+    createEditorInstance() {
+      this.editorInstance = RED.editor.createEditor({
+        id: this.editorId,
+        mode: this.language,
+        value: this.effectiveValue
+      }), this.editorInstance.getSession().on("change", () => {
+        const e = this.editorInstance.getValue();
+        e !== this.effectiveValue && (this.$emit("update:modelValue", e), this.$emit("update:value", e));
+      }), this.$emit("editor-ready", this.editorInstance);
+    },
+    createExpandeEditorTray() {
+      let e;
+      const t = () => {
+        setTimeout(() => {
+          var r;
+          (r = this.editorInstance) == null || r.focus();
+        }, 250), RED.tray.close();
+      }, n = () => {
+        var r;
+        e.saveView(), (r = this.editorInstance) == null || r.setValue(e.getValue(), -1), setTimeout(() => {
+          var s, d;
+          (s = this.editorInstance) == null || s.restoreView(), (d = this.editorInstance) == null || d.focus();
+        }, 250), RED.tray.close();
+      };
+      this.expandedEditorTray = {
+        title: "Editor",
+        focusElement: !0,
+        width: "Infinity",
+        buttons: [
+          {
+            id: "node-dialog-cancel",
+            text: RED._("common.label.cancel"),
+            click: t
+          },
+          {
+            id: "node-dialog-ok",
+            text: RED._("common.label.done"),
+            class: "primary",
+            click: n
+          }
+        ],
+        open: (r) => {
+          const s = $(
+            '<form id="dialog-form" class="form-horizontal" autocomplete="off"></form>'
+          ).appendTo(r.find(".red-ui-tray-body"));
+          s.html(
+            '<div id="expanded-editor-input" style="height: 100%"></div>'
+          ), e = RED.editor.createEditor({
+            id: "expanded-editor-input",
+            stateId: this.stateId,
+            mode: this.language,
+            focus: !0,
+            value: this.effectiveValue
+          }), s.i18n();
+          const d = r.find(".red-ui-tray-body")[0], a = document.createElement("div");
+          a.className = "red-ui-tray-footer", d.insertAdjacentElement("afterend", a), this.trayElement = a, this.$emit("tray-open", this.trayElement);
+        },
+        close: () => {
+          this.$emit("tray-close"), this.trayElement && (this.trayElement.remove(), this.trayElement = null), e.destroy();
+        }
+      };
+    },
+    onClickExpand() {
+      RED.tray.show(this.expandedEditorTray);
+    }
+  }
+}), ke = {
+  ref: "container",
+  class: "container"
+}, Se = { class: "editor-wrapper" }, qe = ["id"];
+function Ne(e, t, n, r, s, d) {
+  const a = g("NodeRedInputLabel");
+  return l(), c(
+    "div",
+    ke,
+    [
+      w(e.$slots, "label", {}, () => [
+        e.label ? (l(), v(a, {
+          key: 0,
+          label: e.label,
+          icon: e.icon,
+          required: e.required
+        }, null, 8, ["label", "icon", "required"])) : f("v-if", !0)
+      ], !0),
+      m("div", Se, [
+        m(
+          "button",
+          {
+            ref: "expand-button",
+            class: "red-ui-button red-ui-button-small expand-button",
+            onClick: t[0] || (t[0] = (...h) => e.onClickExpand && e.onClickExpand(...h))
+          },
+          [...t[1] || (t[1] = [
+            m(
+              "i",
+              { class: "fa fa-expand" },
+              null,
+              -1
+              /* CACHED */
+            )
+          ])],
+          512
+          /* NEED_PATCH */
+        ),
+        m("div", {
+          id: e.editorId,
+          ref: "editor"
+        }, null, 8, qe)
+      ]),
+      H(m(
+        "div",
+        { class: "node-red-vue-input-error-message" },
+        T(e.error),
+        513
+        /* TEXT, NEED_PATCH */
+      ), [
+        [J, e.error]
+      ]),
+      e.trayElement ? (l(), v(K, {
+        key: 0,
+        to: e.trayElement
+      }, [
+        w(e.$slots, "tray-footer", {}, void 0, !0)
+      ], 8, ["to"])) : f("v-if", !0)
+    ],
+    512
+    /* NEED_PATCH */
+  );
+}
+const M = /* @__PURE__ */ E(we, [["render", Ne], ["__scopeId", "data-v-ea93e881"]]), Re = V({
+  name: "NodeRedToggle",
+  props: {
+    modelValue: {
+      type: Boolean,
+      default: !1
+    },
+    label: {
+      type: String,
+      default: ""
+    },
+    icon: {
+      type: String,
+      default: ""
+    }
+  },
+  emits: ["update:modelValue"],
+  computed: {
+    iconClass() {
+      return this.icon ? `fa ${this.icon.startsWith("fa-") ? this.icon : `fa-${this.icon}`}` : "";
+    }
+  }
+}), _e = { class: "nrg-toggle-wrapper" }, Le = ["checked"], je = {
+  key: 0,
+  class: "nrg-toggle__label"
+};
+function Ce(e, t, n, r, s, d) {
+  return l(), c("div", _e, [
+    m(
+      "label",
+      {
+        class: R(["nrg-toggle", { "nrg-toggle--checked": e.modelValue }])
+      },
+      [
+        m("input", {
+          type: "checkbox",
+          checked: e.modelValue,
+          class: "nrg-toggle__input",
+          onChange: t[0] || (t[0] = (a) => e.$emit(
+            "update:modelValue",
+            a.target.checked
+          ))
+        }, null, 40, Le),
+        e.icon || e.label ? (l(), c("span", je, [
+          e.icon ? (l(), c(
+            "i",
+            {
+              key: 0,
+              class: R(e.iconClass)
+            },
+            null,
+            2
+            /* CLASS */
+          )) : f("v-if", !0),
+          D(
+            " " + T(e.label),
+            1
+            /* TEXT */
+          )
+        ])) : f("v-if", !0),
+        t[1] || (t[1] = m(
+          "span",
+          { class: "nrg-toggle__slider" },
+          null,
+          -1
+          /* CACHED */
+        ))
+      ],
+      2
+      /* CLASS */
+    )
+  ]);
+}
+const P = /* @__PURE__ */ E(Re, [["render", Ce], ["__scopeId", "data-v-724dcae4"]]), Ae = /* @__PURE__ */ new Set([
+  "id",
+  "type",
+  "x",
+  "y",
+  "z",
+  "g",
+  "wires",
+  "credentials",
+  "_users",
+  "validateInput",
+  "validateOutput",
+  "outputs",
+  "returnProperty",
+  ...ue
+]);
+function Oe(e) {
+  return e.replace(/([A-Z])/g, " $1").replace(/^./, (t) => t.toUpperCase()).trim();
+}
+function De(e) {
+  var t, n;
+  return e.type === "object" && !!((t = e.properties) != null && t.value) && !!((n = e.properties) != null && n.type);
+}
+function A(e, t, n, r) {
+  var b;
+  const s = r || t.title || Oe(e), d = t["x-nrg-form"] ?? {}, a = d.icon || "";
+  if (t["x-nrg-node-type"])
+    return {
+      key: e,
+      label: s,
+      icon: a,
+      inputType: "config",
+      required: n,
+      configType: t["x-nrg-node-type"]
+    };
+  if (De(t))
+    return {
+      key: e,
+      label: s,
+      icon: a,
+      inputType: "typed",
+      required: n,
+      // serialized schemas carry plain strings; trust them as typed-input type names
+      types: d.typedInputTypes
+    };
+  if (t.type === "array" && ((b = t.items) != null && b.enum))
+    return {
+      key: e,
+      label: s,
+      icon: a,
+      inputType: "select",
+      required: n,
+      multiple: !0,
+      options: t.items.enum.map((i) => ({
+        value: String(i),
+        label: String(i)
+      }))
+    };
+  if (t.enum)
+    return {
+      key: e,
+      label: s,
+      icon: a,
+      inputType: "select",
+      required: n,
+      multiple: !1,
+      options: t.enum.map((i) => ({
+        value: String(i),
+        label: String(i)
+      }))
+    };
+  if (t.anyOf && t.anyOf.every((i) => i.const !== void 0))
+    return {
+      key: e,
+      label: s,
+      icon: a,
+      inputType: "select",
+      required: n,
+      multiple: !1,
+      options: t.anyOf.map((i) => ({
+        value: String(i.const),
+        label: String(i.const)
+      }))
+    };
+  switch (Array.isArray(t.type) ? t.type[0] : t.type) {
+    case "boolean":
+      return {
+        key: e,
+        label: s,
+        icon: a,
+        inputType: "boolean",
+        required: n,
+        toggle: d.toggle
+      };
+    case "number":
+    case "integer":
+      return {
+        key: e,
+        label: s,
+        icon: a,
+        inputType: "number",
+        required: n,
+        htmlType: "number"
+      };
+    case "array":
+      return d.editorLanguage ? {
+        key: e,
+        label: s,
+        icon: a,
+        inputType: "editor",
+        required: n,
+        language: d.editorLanguage
+      } : { key: e, label: s, icon: a, inputType: "array-text", required: n };
+    case "object":
+      return d.editorLanguage ? {
+        key: e,
+        label: s,
+        icon: a,
+        inputType: "editor",
+        required: n,
+        language: d.editorLanguage
+      } : {
+        key: e,
+        label: s,
+        icon: a,
+        inputType: "text",
+        required: n,
+        htmlType: "text"
+      };
+    default:
+      return d.editorLanguage ? {
+        key: e,
+        label: s,
+        icon: a,
+        inputType: "editor",
+        required: n,
+        language: d.editorLanguage
+      } : {
+        key: e,
+        label: s,
+        icon: a,
+        inputType: "text",
+        required: n,
+        htmlType: t.format === "password" ? "password" : "text"
+      };
+  }
+}
+const We = V({
+  name: "NodeRedJsonSchemaForm",
+  components: {
+    NodeRedInputLabel: k,
+    NodeRedToggle: P,
+    NodeRedInput: W,
+    NodeRedSelectInput: F,
+    NodeRedTypedInput: B,
+    NodeRedConfigInput: U,
+    NodeRedEditorInput: M
+  },
+  props: {
+    node: {
+      type: Object,
+      required: !0
+    },
+    schema: {
+      type: Object,
+      required: !0
+    },
+    errors: {
+      type: Object,
+      default: () => ({})
+    }
+  },
+  computed: {
+    configFields() {
+      var t;
+      if (!((t = this.schema) != null && t.properties)) return [];
+      const e = new Set(this.schema.required ?? []);
+      return Object.entries(this.schema.properties).filter(([n]) => !Ae.has(n)).map(
+        ([n, r]) => A(
+          n,
+          r,
+          e.has(n),
+          this.resolveI18n("configs", n)
+        )
+      );
+    },
+    credentialFields() {
+      var n, r;
+      const e = (r = (n = this.schema) == null ? void 0 : n.properties) == null ? void 0 : r.credentials;
+      if (!(e != null && e.properties)) return [];
+      const t = new Set(e.required ?? []);
+      return Object.entries(e.properties).map(([s, d]) => {
+        const a = A(
+          s,
+          d,
+          t.has(s),
+          this.resolveI18n("credentials", s)
+        );
+        return a.inputType !== "text" ? {
+          ...a,
+          inputType: "text",
+          htmlType: d.format === "password" ? "password" : "text"
+        } : a;
+      });
+    }
+  },
+  methods: {
+    resolveI18n(e, t) {
+      const n = this.$i18n(`${e}.${t}`), r = `${this.node.type}.${e}.${t}`;
+      if (n && n !== r && n !== `${e}.${t}`)
+        return n;
+    }
+  }
+}), Be = { key: 1 }, Ue = { key: 2 }, Fe = ["checked", "onChange"], Me = { key: 6 }, Pe = ["value", "onInput"], ze = {
+  key: 0,
+  class: "node-red-vue-input-error-message"
+};
+function He(e, t, n, r, s, d) {
+  const a = g("NodeRedInput"), h = g("NodeRedToggle"), b = g("NodeRedInputLabel"), i = g("NodeRedSelectInput"), u = g("NodeRedTypedInput"), y = g("NodeRedConfigInput"), I = g("NodeRedEditorInput");
+  return l(), c("div", null, [
+    (l(!0), c(
+      _,
+      null,
+      L(e.configFields, (o) => (l(), c("div", {
+        key: o.key,
+        class: "form-row"
+      }, [
+        o.inputType === "text" || o.inputType === "number" ? (l(), v(a, {
+          key: 0,
+          value: e.node[o.key],
+          "onUpdate:value": (p) => e.node[o.key] = p,
+          type: o.htmlType,
+          label: o.label,
+          icon: o.icon,
+          required: o.required,
+          error: e.errors[`node.${o.key}`]
+        }, null, 8, ["value", "onUpdate:value", "type", "label", "icon", "required", "error"])) : o.inputType === "boolean" && o.toggle ? (l(), c("div", Be, [
+          N(h, {
+            "model-value": e.node[o.key],
+            label: o.label,
+            icon: o.icon,
+            "onUpdate:modelValue": (p) => e.node[o.key] = p
+          }, null, 8, ["model-value", "label", "icon", "onUpdate:modelValue"])
+        ])) : o.inputType === "boolean" ? (l(), c("div", Ue, [
+          N(b, {
+            label: o.label,
+            icon: o.icon,
+            required: o.required
+          }, null, 8, ["label", "icon", "required"]),
+          m("input", {
+            type: "checkbox",
+            checked: e.node[o.key],
+            style: { width: "auto", margin: "0" },
+            onChange: (p) => {
+              e.node[o.key] = p.target.checked;
+            }
+          }, null, 40, Fe)
+        ])) : o.inputType === "select" ? (l(), v(i, {
+          key: 3,
+          value: e.node[o.key],
+          "onUpdate:value": (p) => e.node[o.key] = p,
+          options: o.options,
+          multiple: o.multiple,
+          label: o.label,
+          icon: o.icon,
+          required: o.required,
+          error: e.errors[`node.${o.key}`]
+        }, null, 8, ["value", "onUpdate:value", "options", "multiple", "label", "icon", "required", "error"])) : o.inputType === "typed" ? (l(), v(u, {
+          key: 4,
+          value: e.node[o.key],
+          "onUpdate:value": (p) => e.node[o.key] = p,
+          types: o.types,
+          label: o.label,
+          icon: o.icon,
+          required: o.required,
+          error: e.errors[`node.${o.key}`]
+        }, null, 8, ["value", "onUpdate:value", "types", "label", "icon", "required", "error"])) : o.inputType === "config" ? (l(), v(y, {
+          key: 5,
+          value: e.node[o.key],
+          "onUpdate:value": (p) => e.node[o.key] = p,
+          type: o.configType,
+          node: e.node,
+          "prop-name": o.key,
+          label: o.label,
+          icon: o.icon,
+          required: o.required,
+          error: e.errors[`node.${o.key}`]
+        }, null, 8, ["value", "onUpdate:value", "type", "node", "prop-name", "label", "icon", "required", "error"])) : o.inputType === "array-text" ? (l(), c("div", Me, [
+          N(b, {
+            label: o.label,
+            icon: o.icon,
+            required: o.required
+          }, null, 8, ["label", "icon", "required"]),
+          t[0] || (t[0] = m(
+            "span",
+            { style: { display: "block", "font-size": "11px", color: "var(--red-ui-text-color-disabled, #999)", "margin-bottom": "4px" } },
+            " One entry per line ",
+            -1
+            /* CACHED */
+          )),
+          m("textarea", {
+            value: Array.isArray(e.node[o.key]) ? e.node[o.key].join(`
+`) : e.node[o.key] ?? "",
+            rows: "4",
+            style: { width: "100%", resize: "vertical", "font-family": "monospace", "font-size": "13px" },
+            onInput: (p) => e.node[o.key] = p.target.value.split(`
+`).filter(Boolean)
+          }, null, 40, Pe),
+          e.errors[`node.${o.key}`] ? (l(), c(
+            "span",
+            ze,
+            T(e.errors[`node.${o.key}`]),
+            1
+            /* TEXT */
+          )) : f("v-if", !0)
+        ])) : o.inputType === "editor" ? (l(), v(I, {
+          key: 7,
+          value: e.node[o.key],
+          "onUpdate:value": (p) => e.node[o.key] = p,
+          language: o.language,
+          label: o.label,
+          icon: o.icon,
+          required: o.required,
+          error: e.errors[`node.${o.key}`]
+        }, null, 8, ["value", "onUpdate:value", "language", "label", "icon", "required", "error"])) : f("v-if", !0)
+      ]))),
+      128
+      /* KEYED_FRAGMENT */
+    )),
+    (l(!0), c(
+      _,
+      null,
+      L(e.credentialFields, (o) => (l(), c("div", {
+        key: `cred-${o.key}`,
+        class: "form-row"
+      }, [
+        N(a, {
+          value: e.node.credentials[o.key],
+          "onUpdate:value": (p) => e.node.credentials[o.key] = p,
+          type: o.htmlType,
+          label: o.label,
+          icon: o.icon,
+          required: o.required,
+          error: e.errors[`node.credentials.${o.key}`]
+        }, null, 8, ["value", "onUpdate:value", "type", "label", "icon", "required", "error"])
+      ]))),
+      128
+      /* KEYED_FRAGMENT */
+    ))
+  ]);
+}
+const Je = /* @__PURE__ */ E(We, [["render", He]]);
+O.global.mocks.$i18n = (e) => e;
+O.global.components = {
+  NodeRedInputLabel: k,
+  NodeRedToggle: P,
+  NodeRedInput: W,
+  NodeRedTypedInput: B,
+  NodeRedConfigInput: U,
+  NodeRedSelectInput: F,
+  NodeRedEditorInput: M,
+  NodeRedJsonSchemaForm: Je
+};
+window.$ = X();
+window.RED = Z();
+z(() => {
+  Q(window.RED);
 });