@knime/scripting-editor 0.0.5 → 0.0.6

package/dist/knime-scripting-editor.js

@@ -1,13 +1,1493 @@
-(function(){"use strict";try{if(typeof document<"u"){var e=document.createElement("style");e.appendChild(document.createTextNode(".code-editor[data-v-6ef3894e]{height:100%}")),document.head.appendChild(e)}}catch(t){console.error("vite-plugin-css-injected-by-js",t)}})();
-import { defineComponent as l, ref as c, onMounted as d, openBlock as s, createElementBlock as u } from "vue";
-import * as i from "monaco-editor";
-const p = /* @__PURE__ */ l({
-  __name: "CodeEditor",
+(function(){"use strict";try{if(typeof document<"u"){var e=document.createElement("style");e.appendChild(document.createTextNode('.splitpanes{display:flex;width:100%;height:100%}.splitpanes--vertical{flex-direction:row}.splitpanes--horizontal{flex-direction:column}.splitpanes--dragging *{-webkit-user-select:none;-moz-user-select:none;user-select:none}.splitpanes__pane{width:100%;height:100%;overflow:hidden}.splitpanes--vertical .splitpanes__pane{transition:width .2s ease-out}.splitpanes--horizontal .splitpanes__pane{transition:height .2s ease-out}.splitpanes--dragging .splitpanes__pane{transition:none}.splitpanes__splitter{touch-action:none}.splitpanes--vertical>.splitpanes__splitter{min-width:1px;cursor:col-resize}.splitpanes--horizontal>.splitpanes__splitter{min-height:1px;cursor:row-resize}.splitpanes.default-theme .splitpanes__pane{background-color:#f2f2f2}.splitpanes.default-theme .splitpanes__splitter{background-color:#fff;box-sizing:border-box;position:relative;flex-shrink:0}.splitpanes.default-theme .splitpanes__splitter:before,.splitpanes.default-theme .splitpanes__splitter:after{content:"";position:absolute;top:50%;left:50%;background-color:#00000026;transition:background-color .3s}.splitpanes.default-theme .splitpanes__splitter:hover:before,.splitpanes.default-theme .splitpanes__splitter:hover:after{background-color:#00000040}.splitpanes.default-theme .splitpanes__splitter:first-child{cursor:auto}.default-theme.splitpanes .splitpanes .splitpanes__splitter{z-index:1}.default-theme.splitpanes--vertical>.splitpanes__splitter,.default-theme .splitpanes--vertical>.splitpanes__splitter{width:7px;border-left:1px solid #eee;margin-left:-1px}.default-theme.splitpanes--vertical>.splitpanes__splitter:before,.default-theme.splitpanes--vertical>.splitpanes__splitter:after,.default-theme .splitpanes--vertical>.splitpanes__splitter:before,.default-theme .splitpanes--vertical>.splitpanes__splitter:after{transform:translateY(-50%);width:1px;height:30px}.default-theme.splitpanes--vertical>.splitpanes__splitter:before,.default-theme .splitpanes--vertical>.splitpanes__splitter:before{margin-left:-2px}.default-theme.splitpanes--vertical>.splitpanes__splitter:after,.default-theme .splitpanes--vertical>.splitpanes__splitter:after{margin-left:1px}.default-theme.splitpanes--horizontal>.splitpanes__splitter,.default-theme .splitpanes--horizontal>.splitpanes__splitter{height:7px;border-top:1px solid #eee;margin-top:-1px}.default-theme.splitpanes--horizontal>.splitpanes__splitter:before,.default-theme.splitpanes--horizontal>.splitpanes__splitter:after,.default-theme .splitpanes--horizontal>.splitpanes__splitter:before,.default-theme .splitpanes--horizontal>.splitpanes__splitter:after{transform:translate(-50%);width:30px;height:1px}.default-theme.splitpanes--horizontal>.splitpanes__splitter:before,.default-theme .splitpanes--horizontal>.splitpanes__splitter:before{margin-top:-2px}.default-theme.splitpanes--horizontal>.splitpanes__splitter:after,.default-theme .splitpanes--horizontal>.splitpanes__splitter:after{margin-top:1px}.code-editor[data-v-2a674232]{height:100%}.layout[data-v-52dc9a8f]{--controls-height: 49px;--description-button-size: 15px;display:flex;flex-direction:column;height:calc(100vh - 15px);width:100%;border-left:1px solid var(--knime-silver-sand)}.common-splitter[data-v-52dc9a8f] .splitpanes__splitter{min-width:11px;min-height:11px;background-color:var(--knime-porcelain);background-repeat:no-repeat;background-position:center;border-color:var(--knime-silver-sand);border-style:solid}.splitpanes--vertical[data-v-52dc9a8f]>.splitpanes__splitter{border-width:0 1px}.splitpanes--horizontal[data-v-52dc9a8f]>.splitpanes__splitter{border-width:1px 0}.left-facing-splitter[data-v-52dc9a8f]>.splitpanes__splitter{background-image:url(data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHZpZXdCb3g9IjAgMCAzMiAzMiIKICAgIGZpbGw9Im5vbmUiIHN0cm9rZT0iIzAwMCIgc3Ryb2tlLWxpbmVqb2luPSJyb3VuZCI+CiAgPHBhdGggZD0iTTIxLjUgMjdsLTExLTExIDExLTExIi8+Cjwvc3ZnPgo=)}.right-facing-splitter[data-v-52dc9a8f]>.splitpanes__splitter{background-image:url(data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHZpZXdCb3g9IjAgMCAzMiAzMiIKICAgIGZpbGw9Im5vbmUiIHN0cm9rZT0iIzAwMCIgc3Ryb2tlLWxpbmVqb2luPSJyb3VuZCI+CiAgPHBhdGggZD0iTTEwLjUgNWwxMSAxMS0xMSAxMSIvPgo8L3N2Zz4K)}.down-facing-splitter[data-v-52dc9a8f]>.splitpanes__splitter{background-image:url(data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHZpZXdCb3g9IjAgMCAzMiAzMiIKICAgIHN0cm9rZT0iIzAwMCIgZmlsbD0ibm9uZSIgc3Ryb2tlLWxpbmVqb2luPSJyb3VuZCI+CiAgPHBhdGggZD0iTTI4LjcgOS43TDE2IDIyLjMgMy4zIDkuNyIvPgo8L3N2Zz4K)}.up-facing-splitter[data-v-52dc9a8f]>.splitpanes__splitter{background-image:url(data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHZpZXdCb3g9IjAgMCAzMiAzMiIKICAgIHN0cm9rZT0iIzAwMCIgZmlsbD0ibm9uZSIgc3Ryb2tlLWxpbmVqb2luPSJyb3VuZCI+CiAgPHBhdGggZD0iTTI4LjcgOS43TDE2IDIyLjMgMy4zIDkuNyIvPgo8L3N2Zz4K);transform:scaleY(-1)}.splitpanes__pane[data-v-52dc9a8f]{transition:none 0s ease 0s;transition:initial}')),document.head.appendChild(e)}}catch(t){console.error("vite-plugin-css-injected-by-js",t)}})();
+var J = Object.defineProperty;
+var W = (e, t, i) => t in e ? J(e, t, { enumerable: !0, configurable: !0, writable: !0, value: i }) : e[t] = i;
+var f = (e, t, i) => (W(e, typeof t != "symbol" ? t + "" : t, i), i);
+import { h as X, openBlock as D, createElementBlock as N, normalizeStyle as K, renderSlot as y, defineComponent as q, ref as Y, onMounted as Q, onUnmounted as Z, resolveComponent as x, createVNode as p, normalizeClass as M, withCtx as m } from "vue";
+import * as C from "monaco-editor";
+const ee = {
+  name: "splitpanes",
+  emits: ["ready", "resize", "resized", "pane-click", "pane-maximize", "pane-add", "pane-remove", "splitter-click"],
   props: {
-    initialScript: {
-      type: String,
-      default: ""
+    horizontal: { type: Boolean },
+    pushOtherPanes: { type: Boolean, default: !0 },
+    dblClickSplitter: { type: Boolean, default: !0 },
+    rtl: { type: Boolean, default: !1 },
+    firstSplitter: { type: Boolean }
+  },
+  provide() {
+    return {
+      requestUpdate: this.requestUpdate,
+      onPaneAdd: this.onPaneAdd,
+      onPaneRemove: this.onPaneRemove,
+      onPaneClick: this.onPaneClick
+    };
+  },
+  data: () => ({
+    container: null,
+    ready: !1,
+    panes: [],
+    touch: {
+      mouseDown: !1,
+      dragging: !1,
+      activeSplitter: null
+    },
+    splitterTaps: {
+      splitter: null,
+      timeoutId: null
+    }
+  }),
+  computed: {
+    panesCount() {
+      return this.panes.length;
+    },
+    indexedPanes() {
+      return this.panes.reduce((e, t) => (e[t.id] = t) && e, {});
+    }
+  },
+  methods: {
+    updatePaneComponents() {
+      this.panes.forEach((e) => {
+        e.update && e.update({
+          [this.horizontal ? "height" : "width"]: `${this.indexedPanes[e.id].size}%`
+        });
+      });
+    },
+    bindEvents() {
+      document.addEventListener("mousemove", this.onMouseMove, { passive: !1 }), document.addEventListener("mouseup", this.onMouseUp), "ontouchstart" in window && (document.addEventListener("touchmove", this.onMouseMove, { passive: !1 }), document.addEventListener("touchend", this.onMouseUp));
+    },
+    unbindEvents() {
+      document.removeEventListener("mousemove", this.onMouseMove, { passive: !1 }), document.removeEventListener("mouseup", this.onMouseUp), "ontouchstart" in window && (document.removeEventListener("touchmove", this.onMouseMove, { passive: !1 }), document.removeEventListener("touchend", this.onMouseUp));
+    },
+    onMouseDown(e, t) {
+      this.bindEvents(), this.touch.mouseDown = !0, this.touch.activeSplitter = t;
+    },
+    onMouseMove(e) {
+      this.touch.mouseDown && (e.preventDefault(), this.touch.dragging = !0, this.calculatePanesSize(this.getCurrentMouseDrag(e)), this.$emit("resize", this.panes.map((t) => ({ min: t.min, max: t.max, size: t.size }))));
+    },
+    onMouseUp() {
+      this.touch.dragging && this.$emit("resized", this.panes.map((e) => ({ min: e.min, max: e.max, size: e.size }))), this.touch.mouseDown = !1, setTimeout(() => {
+        this.touch.dragging = !1, this.unbindEvents();
+      }, 100);
+    },
+    onSplitterClick(e, t) {
+      "ontouchstart" in window && (e.preventDefault(), this.dblClickSplitter && (this.splitterTaps.splitter === t ? (clearTimeout(this.splitterTaps.timeoutId), this.splitterTaps.timeoutId = null, this.onSplitterDblClick(e, t), this.splitterTaps.splitter = null) : (this.splitterTaps.splitter = t, this.splitterTaps.timeoutId = setTimeout(() => {
+        this.splitterTaps.splitter = null;
+      }, 500)))), this.touch.dragging || this.$emit("splitter-click", this.panes[t]);
+    },
+    onSplitterDblClick(e, t) {
+      let i = 0;
+      this.panes = this.panes.map((n, s) => (n.size = s === t ? n.max : n.min, s !== t && (i += n.min), n)), this.panes[t].size -= i, this.$emit("pane-maximize", this.panes[t]), this.$emit("resized", this.panes.map((n) => ({ min: n.min, max: n.max, size: n.size })));
+    },
+    onPaneClick(e, t) {
+      this.$emit("pane-click", this.indexedPanes[t]);
+    },
+    getCurrentMouseDrag(e) {
+      const t = this.container.getBoundingClientRect(), { clientX: i, clientY: n } = "ontouchstart" in window && e.touches ? e.touches[0] : e;
+      return {
+        x: i - t.left,
+        y: n - t.top
+      };
+    },
+    getCurrentDragPercentage(e) {
+      e = e[this.horizontal ? "y" : "x"];
+      const t = this.container[this.horizontal ? "clientHeight" : "clientWidth"];
+      return this.rtl && !this.horizontal && (e = t - e), e * 100 / t;
+    },
+    calculatePanesSize(e) {
+      const t = this.touch.activeSplitter;
+      let i = {
+        prevPanesSize: this.sumPrevPanesSize(t),
+        nextPanesSize: this.sumNextPanesSize(t),
+        prevReachedMinPanes: 0,
+        nextReachedMinPanes: 0
+      };
+      const n = 0 + (this.pushOtherPanes ? 0 : i.prevPanesSize), s = 100 - (this.pushOtherPanes ? 0 : i.nextPanesSize), a = Math.max(Math.min(this.getCurrentDragPercentage(e), s), n);
+      let r = [t, t + 1], o = this.panes[r[0]] || null, l = this.panes[r[1]] || null;
+      const u = o.max < 100 && a >= o.max + i.prevPanesSize, d = l.max < 100 && a <= 100 - (l.max + this.sumNextPanesSize(t + 1));
+      if (u || d) {
+        u ? (o.size = o.max, l.size = Math.max(100 - o.max - i.prevPanesSize - i.nextPanesSize, 0)) : (o.size = Math.max(100 - l.max - i.prevPanesSize - this.sumNextPanesSize(t + 1), 0), l.size = l.max);
+        return;
+      }
+      if (this.pushOtherPanes) {
+        const h = this.doPushOtherPanes(i, a);
+        if (!h)
+          return;
+        ({ sums: i, panesToResize: r } = h), o = this.panes[r[0]] || null, l = this.panes[r[1]] || null;
+      }
+      o !== null && (o.size = Math.min(Math.max(a - i.prevPanesSize - i.prevReachedMinPanes, o.min), o.max)), l !== null && (l.size = Math.min(Math.max(100 - a - i.nextPanesSize - i.nextReachedMinPanes, l.min), l.max));
+    },
+    doPushOtherPanes(e, t) {
+      const i = this.touch.activeSplitter, n = [i, i + 1];
+      return t < e.prevPanesSize + this.panes[n[0]].min && (n[0] = this.findPrevExpandedPane(i).index, e.prevReachedMinPanes = 0, n[0] < i && this.panes.forEach((s, a) => {
+        a > n[0] && a <= i && (s.size = s.min, e.prevReachedMinPanes += s.min);
+      }), e.prevPanesSize = this.sumPrevPanesSize(n[0]), n[0] === void 0) ? (e.prevReachedMinPanes = 0, this.panes[0].size = this.panes[0].min, this.panes.forEach((s, a) => {
+        a > 0 && a <= i && (s.size = s.min, e.prevReachedMinPanes += s.min);
+      }), this.panes[n[1]].size = 100 - e.prevReachedMinPanes - this.panes[0].min - e.prevPanesSize - e.nextPanesSize, null) : t > 100 - e.nextPanesSize - this.panes[n[1]].min && (n[1] = this.findNextExpandedPane(i).index, e.nextReachedMinPanes = 0, n[1] > i + 1 && this.panes.forEach((s, a) => {
+        a > i && a < n[1] && (s.size = s.min, e.nextReachedMinPanes += s.min);
+      }), e.nextPanesSize = this.sumNextPanesSize(n[1] - 1), n[1] === void 0) ? (e.nextReachedMinPanes = 0, this.panes[this.panesCount - 1].size = this.panes[this.panesCount - 1].min, this.panes.forEach((s, a) => {
+        a < this.panesCount - 1 && a >= i + 1 && (s.size = s.min, e.nextReachedMinPanes += s.min);
+      }), this.panes[n[0]].size = 100 - e.prevPanesSize - e.nextReachedMinPanes - this.panes[this.panesCount - 1].min - e.nextPanesSize, null) : { sums: e, panesToResize: n };
+    },
+    sumPrevPanesSize(e) {
+      return this.panes.reduce((t, i, n) => t + (n < e ? i.size : 0), 0);
+    },
+    sumNextPanesSize(e) {
+      return this.panes.reduce((t, i, n) => t + (n > e + 1 ? i.size : 0), 0);
+    },
+    findPrevExpandedPane(e) {
+      return [...this.panes].reverse().find((t) => t.index < e && t.size > t.min) || {};
+    },
+    findNextExpandedPane(e) {
+      return this.panes.find((t) => t.index > e + 1 && t.size > t.min) || {};
+    },
+    checkSplitpanesNodes() {
+      Array.from(this.container.children).forEach((e) => {
+        const t = e.classList.contains("splitpanes__pane"), i = e.classList.contains("splitpanes__splitter");
+        !t && !i && (e.parentNode.removeChild(e), console.warn("Splitpanes: Only <pane> elements are allowed at the root of <splitpanes>. One of your DOM nodes was removed."));
+      });
     },
+    addSplitter(e, t, i = !1) {
+      const n = e - 1, s = document.createElement("div");
+      s.classList.add("splitpanes__splitter"), i || (s.onmousedown = (a) => this.onMouseDown(a, n), typeof window < "u" && "ontouchstart" in window && (s.ontouchstart = (a) => this.onMouseDown(a, n)), s.onclick = (a) => this.onSplitterClick(a, n + 1)), this.dblClickSplitter && (s.ondblclick = (a) => this.onSplitterDblClick(a, n + 1)), t.parentNode.insertBefore(s, t);
+    },
+    removeSplitter(e) {
+      e.onmousedown = void 0, e.onclick = void 0, e.ondblclick = void 0, e.parentNode.removeChild(e);
+    },
+    redoSplitters() {
+      const e = Array.from(this.container.children);
+      e.forEach((i) => {
+        i.className.includes("splitpanes__splitter") && this.removeSplitter(i);
+      });
+      let t = 0;
+      e.forEach((i) => {
+        i.className.includes("splitpanes__pane") && (!t && this.firstSplitter ? this.addSplitter(t, i, !0) : t && this.addSplitter(t, i), t++);
+      });
+    },
+    requestUpdate({ target: e, ...t }) {
+      const i = this.indexedPanes[e._.uid];
+      Object.entries(t).forEach(([n, s]) => i[n] = s);
+    },
+    onPaneAdd(e) {
+      let t = -1;
+      Array.from(e.$el.parentNode.children).some((s) => (s.className.includes("splitpanes__pane") && t++, s === e.$el));
+      const i = parseFloat(e.minSize), n = parseFloat(e.maxSize);
+      this.panes.splice(t, 0, {
+        id: e._.uid,
+        index: t,
+        min: isNaN(i) ? 0 : i,
+        max: isNaN(n) ? 100 : n,
+        size: e.size === null ? null : parseFloat(e.size),
+        givenSize: e.size,
+        update: e.update
+      }), this.panes.forEach((s, a) => s.index = a), this.ready && this.$nextTick(() => {
+        this.redoSplitters(), this.resetPaneSizes({ addedPane: this.panes[t] }), this.$emit("pane-add", { index: t, panes: this.panes.map((s) => ({ min: s.min, max: s.max, size: s.size })) });
+      });
+    },
+    onPaneRemove(e) {
+      const t = this.panes.findIndex((n) => n.id === e._.uid), i = this.panes.splice(t, 1)[0];
+      this.panes.forEach((n, s) => n.index = s), this.$nextTick(() => {
+        this.redoSplitters(), this.resetPaneSizes({ removedPane: { ...i, index: t } }), this.$emit("pane-remove", { removed: i, panes: this.panes.map((n) => ({ min: n.min, max: n.max, size: n.size })) });
+      });
+    },
+    resetPaneSizes(e = {}) {
+      !e.addedPane && !e.removedPane ? this.initialPanesSizing() : this.panes.some((t) => t.givenSize !== null || t.min || t.max < 100) ? this.equalizeAfterAddOrRemove(e) : this.equalize(), this.ready && this.$emit("resized", this.panes.map((t) => ({ min: t.min, max: t.max, size: t.size })));
+    },
+    equalize() {
+      const e = 100 / this.panesCount;
+      let t = 0;
+      const i = [], n = [];
+      this.panes.forEach((s) => {
+        s.size = Math.max(Math.min(e, s.max), s.min), t -= s.size, s.size >= s.max && i.push(s.id), s.size <= s.min && n.push(s.id);
+      }), t > 0.1 && this.readjustSizes(t, i, n);
+    },
+    initialPanesSizing() {
+      let e = 100;
+      const t = [], i = [];
+      let n = 0;
+      this.panes.forEach((a) => {
+        e -= a.size, a.size !== null && n++, a.size >= a.max && t.push(a.id), a.size <= a.min && i.push(a.id);
+      });
+      let s = 100;
+      e > 0.1 && (this.panes.forEach((a) => {
+        a.size === null && (a.size = Math.max(Math.min(e / (this.panesCount - n), a.max), a.min)), s -= a.size;
+      }), s > 0.1 && this.readjustSizes(e, t, i));
+    },
+    equalizeAfterAddOrRemove({ addedPane: e, removedPane: t } = {}) {
+      let i = 100 / this.panesCount, n = 0;
+      const s = [], a = [];
+      e && e.givenSize !== null && (i = (100 - e.givenSize) / (this.panesCount - 1)), this.panes.forEach((r) => {
+        n -= r.size, r.size >= r.max && s.push(r.id), r.size <= r.min && a.push(r.id);
+      }), !(Math.abs(n) < 0.1) && (this.panes.forEach((r) => {
+        e && e.givenSize !== null && e.id === r.id || (r.size = Math.max(Math.min(i, r.max), r.min)), n -= r.size, r.size >= r.max && s.push(r.id), r.size <= r.min && a.push(r.id);
+      }), n > 0.1 && this.readjustSizes(n, s, a));
+    },
+    readjustSizes(e, t, i) {
+      let n;
+      e > 0 ? n = e / (this.panesCount - t.length) : n = e / (this.panesCount - i.length), this.panes.forEach((s, a) => {
+        if (e > 0 && !t.includes(s.id)) {
+          const r = Math.max(Math.min(s.size + n, s.max), s.min), o = r - s.size;
+          e -= o, s.size = r;
+        } else if (!i.includes(s.id)) {
+          const r = Math.max(Math.min(s.size + n, s.max), s.min), o = r - s.size;
+          e -= o, s.size = r;
+        }
+        s.update({
+          [this.horizontal ? "height" : "width"]: `${this.indexedPanes[s.id].size}%`
+        });
+      }), Math.abs(e) > 0.1 && this.$nextTick(() => {
+        this.ready && console.warn("Splitpanes: Could not resize panes correctly due to their constraints.");
+      });
+    }
+  },
+  watch: {
+    panes: {
+      deep: !0,
+      immediate: !1,
+      handler() {
+        this.updatePaneComponents();
+      }
+    },
+    horizontal() {
+      this.updatePaneComponents();
+    },
+    firstSplitter() {
+      this.redoSplitters();
+    },
+    dblClickSplitter(e) {
+      [...this.container.querySelectorAll(".splitpanes__splitter")].forEach((t, i) => {
+        t.ondblclick = e ? (n) => this.onSplitterDblClick(n, i) : void 0;
+      });
+    }
+  },
+  beforeUnmount() {
+    this.ready = !1;
+  },
+  mounted() {
+    this.container = this.$refs.container, this.checkSplitpanesNodes(), this.redoSplitters(), this.resetPaneSizes(), this.$emit("ready"), this.ready = !0;
+  },
+  render() {
+    return X(
+      "div",
+      {
+        ref: "container",
+        class: [
+          "splitpanes",
+          `splitpanes--${this.horizontal ? "horizontal" : "vertical"}`,
+          {
+            "splitpanes--dragging": this.touch.dragging
+          }
+        ]
+      },
+      this.$slots.default()
+    );
+  }
+}, te = (e, t) => {
+  const i = e.__vccOpts || e;
+  for (const [n, s] of t)
+    i[n] = s;
+  return i;
+}, ne = {
+  name: "pane",
+  inject: ["requestUpdate", "onPaneAdd", "onPaneRemove", "onPaneClick"],
+  props: {
+    size: { type: [Number, String], default: null },
+    minSize: { type: [Number, String], default: 0 },
+    maxSize: { type: [Number, String], default: 100 }
+  },
+  data: () => ({
+    style: {}
+  }),
+  mounted() {
+    this.onPaneAdd(this);
+  },
+  beforeUnmount() {
+    this.onPaneRemove(this);
+  },
+  methods: {
+    update(e) {
+      this.style = e;
+    }
+  },
+  computed: {
+    sizeNumber() {
+      return this.size || this.size === 0 ? parseFloat(this.size) : null;
+    },
+    minSizeNumber() {
+      return parseFloat(this.minSize);
+    },
+    maxSizeNumber() {
+      return parseFloat(this.maxSize);
+    }
+  },
+  watch: {
+    sizeNumber(e) {
+      this.requestUpdate({ target: this, size: e });
+    },
+    minSizeNumber(e) {
+      this.requestUpdate({ target: this, min: e });
+    },
+    maxSizeNumber(e) {
+      this.requestUpdate({ target: this, max: e });
+    }
+  }
+};
+function ie(e, t, i, n, s, a) {
+  return D(), N("div", {
+    class: "splitpanes__pane",
+    onClick: t[0] || (t[0] = (r) => a.onPaneClick(r, e._.uid)),
+    style: K(e.style)
+  }, [
+    y(e.$slots, "default")
+  ], 4);
+}
+const se = /* @__PURE__ */ te(ne, [["render", ie]]);
+var g;
+(function(e) {
+  e.ERROR = "error", e.WARN = "warn";
+})(g || (g = {}));
+class ae {
+  /**
+   * @param {ExtensionConfig} extensionConfig - the extension configuration for the associated UI Extension.
+   * @param {CallableService} callableService - the environment-specific "call service" API method.
+   * @param {CallableService} pushEvent - the environment-specific "push event" API method.
+   */
+  constructor(t = null, i = null, n = null) {
+    this.extensionConfig = t, this.callableService = i, this.callablePushEvent = n, this.eventCallbacksMap = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Public service call wrapper with full error handling which can be used by subclasses/typed service
+   * implementations.
+   *
+   * @param {ServiceParameters} serviceParams - service parameters for the service call.
+   * @returns {Promise<CallServiceResponse>} - resolved promise containing error or result depending on response
+   *      success.
+   */
+  async callService(t) {
+    if (!this.extensionConfig) {
+      const a = this.createAlert({
+        subtitle: "Missing extension config",
+        message: "Cannot call service without extension config"
+      });
+      return this.sendError(a), Promise.resolve({});
+    }
+    if (!this.callableService) {
+      const a = this.createAlert({
+        message: "Callable service is not available",
+        subtitle: "Service not found"
+      });
+      return this.sendError(a), Promise.resolve({});
+    }
+    const i = await this.executeServiceCall(t), { error: n, result: s } = i || {};
+    return n && this.sendError(n), Promise.resolve({ result: s });
+  }
+  /**
+   * Inner service call wrapper which can be overridden by subclasses which require specific behavior (e.g. iframes).
+   * Default behavior is to use the member callable service directly.
+   *
+   * @param {ServiceParameters} serviceParams - parameters for the service call.
+   * @returns {Promise} - rejected or resolved depending on response success.
+   */
+  executeServiceCall(t) {
+    return this.callableService(...t);
+  }
+  /**
+   * Register a callback method which returns relevant data to provide when "applying" client-side state
+   * changes to the framework (i.e. when settings change and should be persisted).
+   *
+   * @param {Function} callback - method which returns any data needed by the framework to persist the client-
+   *      side state.
+   * @returns {undefined}
+   */
+  registerDataGetter(t) {
+    this.dataGetter = t;
+  }
+  /**
+   * A framework method to get any data which is needed for state persistence. Not intended to be called directly
+   * by a UI Extension implementation, this method is exposed for lifecycle management by the framework.
+   *
+   * @returns {any | null} optionally returns data needed to persist client side state if a
+   *      {@see KnimeService.dataGetter} has been registered. If no data getter is present,
+   *      returns {@type null}.
+   */
+  getData() {
+    return Promise.resolve(typeof this.dataGetter == "function" ? this.dataGetter() : null);
+  }
+  /**
+   * To be called by the parent application to sent an event to all services. Calls registered callbacks by
+   * event type.
+   * @param {Event} event - event object, which is provided by backend implementation.
+   * @returns {void}
+   */
+  onServiceEvent(t) {
+    (this.eventCallbacksMap.get(t.eventType) || []).forEach((n) => {
+      n(t);
+    });
+  }
+  /**
+   * Registers callback that will be triggered on received events.
+   * @param {EventTypes} eventType - event type that callback should be registered for.
+   * @param {function} callback - callback that should be called on received events, will be called with {Event} param
+   * @returns {void}
+   */
+  addEventCallback(t, i) {
+    this.eventCallbacksMap.set(t, [
+      ...this.eventCallbacksMap.get(t) || [],
+      i
+    ]);
+  }
+  /**
+   * Unregisters previously registered callback for events.
+   * @param {EventTypes} eventType - event type that matches registered callback event type.
+   * @param {function} callback - previously registered callback.
+   * @returns {void}
+   */
+  removeEventCallback(t, i) {
+    this.eventCallbacksMap.set(t, (this.eventCallbacksMap.get(t) || []).filter((n) => n !== i));
+  }
+  /**
+   * Unregisters all previously registered event callbacks of provided event type.
+   * @param {string} eventType - event type that matches registered callbacks event type.
+   * @returns {void}
+   */
+  resetEventCallbacksByType(t) {
+    this.eventCallbacksMap.set(t, []);
+  }
+  /**
+   * Unregisters all previously registered event callbacks of all event types.
+   * @returns {void}
+   */
+  resetEventCallbacks() {
+    this.eventCallbacksMap.clear();
+  }
+  /**
+   * Public push event wrapper with error handling. This broadcasts an event or event
+   * via the callable function provided during instantiation.
+   *
+   * @param {Event} event - the event payload.
+   * @returns {any} - the result of the callable function.
+   */
+  pushEvent(t) {
+    if (!this.extensionConfig) {
+      const i = this.createAlert({
+        subtitle: "Missing extension config",
+        message: "Cannot push event without extension config"
+      });
+      return this.sendError(i), Promise.resolve({});
+    }
+    if (!this.callablePushEvent) {
+      const i = this.createAlert({
+        subtitle: "Push event failed",
+        message: "Push event is not available"
+      });
+      return this.sendError(i), Promise.resolve({});
+    }
+    return this.callablePushEvent(Object.assign({ callerId: this.serviceId }, t));
+  }
+  /**
+   * Pushes error to framework to be displayed to the user.
+   *
+   * @param {Alert} alert - the error alert.
+   * @returns {void}
+   */
+  sendError(t) {
+    this.callablePushEvent ? this.callablePushEvent({
+      callerId: this.serviceId,
+      alert: t,
+      type: "alert"
+    }) : console.error(t);
+  }
+  /**
+   * Pushes warning to framework to be displayed to the user.
+   *
+   * @param {Alert} alert - the warning alert.
+   * @returns {void}
+   */
+  sendWarning(t) {
+    this.callablePushEvent ? this.callablePushEvent({
+      callerId: this.serviceId,
+      alert: t,
+      type: "alert"
+    }) : console.warn(t);
+  }
+  /**
+   * Helper method to create framework compatible {@see Alert} from the available information.
+   *
+   * @param {Object} alertParams - optional parameters for the formatted alert.
+   * @returns {Alert} the properly formatted alert.
+   */
+  createAlert(t) {
+    var i, n;
+    const { type: s = g.ERROR, message: a, code: r, subtitle: o } = t;
+    return {
+      nodeId: ((i = this.extensionConfig) === null || i === void 0 ? void 0 : i.nodeId) || "MISSING",
+      nodeInfo: ((n = this.extensionConfig) === null || n === void 0 ? void 0 : n.nodeInfo) || {},
+      type: s,
+      message: a,
+      code: r,
+      subtitle: o
+    };
+  }
+  /**
+   * Creates an instance ID from a @type {KnimeService}. This ID unique among node instances in a workflow but shared
+   * between KnimeService instances instantiated by the same node instance (i.e. between sessions, refreshes, reloads,
+   * etc.).
+   *
+   * @param {KnimeService} knimeService - the service from which to derive an ID.
+   * @returns {String} the id derived from the provided service.
+   */
+  get serviceId() {
+    const { nodeId: t, projectId: i, workflowId: n, extensionType: s } = this.extensionConfig || {};
+    return `${t}.${i}.${n}.${s}`;
+  }
+}
+var _;
+(function(e) {
+  e.CALL_NODE_DATA_SERVICE = "NodeService.callNodeDataService", e.CALL_NODE_SELECTION_SERVICE = "NodeService.updateDataPointSelection";
+})(_ || (_ = {}));
+var b;
+(function(e) {
+  e.INITIAL_DATA = "initial_data", e.DATA = "data", e.APPLY_DATA = "apply_data";
+})(b || (b = {}));
+var A;
+(function(e) {
+  e.ADD = "ADD", e.REMOVE = "REMOVE", e.REPLACE = "REPLACE";
+})(A || (A = {}));
+var I;
+(function(e) {
+  e.DIALOG = "dialog", e.VIEW = "view";
+})(I || (I = {}));
+var w;
+(function(e) {
+  e.DataEvent = "DataEvent", e.SelectionEvent = "SelectionEvent";
+})(w || (w = {}));
+var $;
+(function(e) {
+  e.HTML = "HTML", e.VUE_COMPONENT_LIB = "VUE_COMPONENT_LIB";
+})($ || ($ = {}));
+let T = 0;
+const O = () => (T += 1, T), re = "2.0", F = (e, t = []) => ({
+  jsonrpc: re,
+  method: e,
+  params: t,
+  id: O()
+}), j = 160;
+class oe {
+  /**
+   * @param {KnimeService<T> | IFrameKnimeService} knimeService - knimeService instance which is used to communicate
+   *      with the framework.
+   */
+  constructor(t) {
+    this.knimeService = t;
+  }
+  /**
+   * Calls the node data service with optional request body. The service to call is specified by the service type
+   * and needs to correspond directly to a {@see DataServiceType} supported by the node.
+   *
+   * @param {DataServiceType} dataServiceType - the data service type.
+   * @param {string} [request] - an optional request payload.
+   * @returns {Promise} rejected or resolved depending on backend response.
+   */
+  callDataService(t, i = "") {
+    return this.knimeService.callService([
+      _.CALL_NODE_DATA_SERVICE,
+      t,
+      i
+    ]).then((n) => typeof n == "string" && n !== "" ? JSON.parse(n) : n);
+  }
+  /**
+   * Retrieves the initial data for the client-side UI Extension implementation from either the local configuration
+   * (if it exists) or by fetching the data from the node DataService implementation.
+   *
+   * @returns {Promise} node initial data provided by the local configuration or by fetching from the DataService.
+   */
+  async initialData() {
+    var t, i;
+    let n;
+    !((t = this.knimeService.extensionConfig) === null || t === void 0) && t.initialData ? n = await Promise.resolve((i = this.knimeService.extensionConfig) === null || i === void 0 ? void 0 : i.initialData) : n = await this.callDataService(b.INITIAL_DATA), typeof n == "string" && (n = JSON.parse(n));
+    const { result: s, warningMessages: a, userError: r, internalError: o } = n || {};
+    return (r || o) && this.handleError(r || o), a && this.handleWarnings(a), Promise.resolve(s);
+  }
+  /**
+   * The state of the settings in a coexisting dialog (if any) when the extension is first loaded.
+   * More precisely, this is the state of the settings on the last clean state of the dialog before
+   * the initialization of the knime service.
+   * It is null if there is no dialog or there was no such state before the initialization.
+   * In particular it is null if the knime service of the view and the dialog are consturcted at the same time.
+   * @returns {DialogSettings | null} the initial dialog state
+   */
+  getDialogSettings() {
+    var t;
+    return ((t = this.knimeService.extensionConfig) === null || t === void 0 ? void 0 : t.dialogSettings) || null;
+  }
+  /**
+   * Retrieve data from the node using the {@see DataServiceType.DATA} api. Different method names can be registered
+   * with the data service in the node implementation to provide targets (specified by the {@param method}). Any
+   * optional parameter will be provided directly to the data service target and can be used to specify the nature of
+   * the data returned.
+   *
+   * @param {Object} params - parameter options.
+   * @param {string} [params.method] - optional target method in the node's DataService implementation
+   *      (default 'getData').
+   * @param {any} [params.options] - optional options that should be passed to called method.
+   * @returns {Promise} rejected or resolved depending on backend response.
+   */
+  async data(t = {}) {
+    const i = await this.callDataService(b.DATA, JSON.stringify(F(t.method || "getData", t.options)));
+    let n = (i == null ? void 0 : i.result) || {};
+    typeof n == "string" && (n = JSON.parse(n));
+    const { error: s, warningMessages: a, result: r } = n;
+    return s && this.handleError(Object.assign(Object.assign({}, s.data || {}), s)), a && this.handleWarnings(a), Promise.resolve(r);
+  }
+  /**
+   * Sends the current client-side data to the backend to be persisted. A data getter method which returns the
+   * data to be applied/saved should be registered *prior* to invoking this method. If none is registered, a
+   * default payload of "null" will be sent instead.
+   *
+   * @returns {Promise} rejected or resolved depending on backend response.
+   */
+  async applyData() {
+    const t = await this.knimeService.getData();
+    return this.callDataService(b.APPLY_DATA, t);
+  }
+  /**
+   * Registers a function with the framework is used to provide the current state of the client-side UI Extension.
+   *
+   * @param {Function} callback - function which provides the current client side state when invoked.
+   * @returns {undefined}
+   */
+  registerDataGetter(t) {
+    this.knimeService.registerDataGetter(() => JSON.stringify(t()));
+  }
+  /**
+   * Adds callback that will be triggered when data changes.
+   * @param {Function} callback - called on data change.
+   * @param {Event} response - the data update event object.
+   * @returns {void}
+   */
+  addOnDataChangeCallback(t) {
+    this.knimeService.addEventCallback(w.DataEvent, t);
+  }
+  /**
+   * Publish a data update event to other UIExtensions registered in the current page.
+   * @param {any} data - the data to send.
+   * @returns {void}
+   */
+  publishData(t) {
+    this.knimeService.pushEvent({
+      event: { data: t, eventType: w.DataEvent }
+    });
+  }
+  handleError(t = {}) {
+    const { details: i = "", stackTrace: n = "", typeName: s = "", message: a = "", code: r } = t;
+    let o = "", l = "";
+    if (a && (a.length <= j ? o = a : l = a), s && (o ? l = s : o = s), i && (l = l ? `${l}
+
+${i}` : i), Array.isArray(n)) {
+      const u = n.join(`
+	`);
+      l = l ? `${l}
+
+${u}` : u;
+    }
+    l = l.trim(), this.knimeService.sendError(this.knimeService.createAlert({
+      subtitle: o || "Something went wrong",
+      message: l || "No further information available. Please check the workflow configuration.",
+      type: g.ERROR,
+      code: r
+    }));
+  }
+  handleWarnings(t) {
+    let i;
+    const n = t == null ? void 0 : t.join(`
+
+`);
+    (t == null ? void 0 : t.length) > 1 ? i = `${t == null ? void 0 : t.length} messages` : (n == null ? void 0 : n.length) > j && (i = "Expand for details"), this.knimeService.sendWarning(this.knimeService.createAlert({
+      type: g.WARN,
+      message: n,
+      subtitle: i
+    }));
+  }
+}
+const E = "knimeUIExtension", U = 1e4, le = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  UI_EXT_POST_MESSAGE_PREFIX: E,
+  UI_EXT_POST_MESSAGE_TIMEOUT: U
+}, Symbol.toStringTag, { value: "Module" }));
+class v extends ae {
+  constructor() {
+    super(), this.pendingServiceCalls = /* @__PURE__ */ new Map(), this.initializationPromise = new Promise((t) => {
+      this.initializationPromiseResolve = t;
+    }), this.extensionConfig && this.initializationPromiseResolve(), this.callableService = this.executeServiceCall, this.callablePushEvent = v.iframePushEvent, this.boundOnMessageFromParent = this.onMessageFromParent.bind(this), window.addEventListener("message", this.boundOnMessageFromParent), v.postMessage({ messageType: "ready" });
+  }
+  /**
+   * Needs to be awaited before the service is ready to be used.
+   * @returns {void}
+   */
+  async waitForInitialization() {
+    await this.initializationPromise;
+  }
+  /**
+   * Called when a new message is received, identifies and handles it if type is supported.
+   * @param {MessageEvent} event - postMessage event that is sent by parent window with event type and payload.
+   * @returns {void}
+   */
+  onMessageFromParent(t) {
+    var i, n;
+    const { data: s } = t;
+    if (!(!((i = s.type) === null || i === void 0) && i.startsWith(E)))
+      return;
+    switch ((n = s.type) === null || n === void 0 ? void 0 : n.replace(`${E}:`, "")) {
+      case "init":
+        this.onInit(s);
+        break;
+      case "callServiceResponse":
+        this.onCallServiceResponse(s);
+        break;
+      case "serviceEvent":
+        this.onServiceEvent(s.payload);
+        break;
+    }
+  }
+  onInit(t) {
+    this.extensionConfig = t.payload, this.initializationPromiseResolve();
+  }
+  onCallServiceResponse(t) {
+    const { payload: { response: i, requestId: n } } = t, s = this.pendingServiceCalls.get(n);
+    if (s) {
+      s.resolve(i), this.pendingServiceCalls.delete(n);
+      return;
+    }
+    const a = this.createAlert({
+      code: "404",
+      subtitle: "Request not found",
+      type: g.ERROR,
+      message: `Received callService response for non-existing pending request with id ${n}`
+    });
+    this.sendError(a);
+  }
+  /**
+   * Overrides method of KnimeService to implement how request should be processed in IFrame environment.
+   * @param {ServiceParameters} serviceParams - parameters for the service call.
+   * @returns {Promise<string>} - promise that resolves with response from the service call string or error message.
+   */
+  executeServiceCall(t) {
+    let i;
+    const n = O(), s = new Promise((a, r) => {
+      this.pendingServiceCalls.set(n, { resolve: a, reject: r }), i = setTimeout(() => {
+        const o = this.createAlert({
+          code: "408",
+          subtitle: "Request Timeout",
+          type: g.ERROR,
+          message: `Request with id ${n} aborted due to timeout.`
+        });
+        this.sendError(o), a(JSON.stringify({ error: o }));
+      }, U);
+    });
+    return s.then(() => {
+      clearTimeout(i);
+    }), v.postMessage({
+      payload: { requestId: n, serviceParams: t },
+      messageType: "callService"
+    }), s;
+  }
+  static postMessage(t) {
+    const { payload: i, messageType: n } = t;
+    window.parent.postMessage({ type: `${E}:${n}`, payload: i }, "*");
+  }
+  static iframePushEvent(t) {
+    return v.postMessage({
+      payload: { event: t },
+      messageType: "event"
+    }), Promise.resolve();
+  }
+  /**
+   * Should be called before destroying IFrameKnimeService, to remove event listeners from window object,
+   * preventing memory leaks and unexpected behavior.
+   * @returns {void}
+   */
+  destroy() {
+    window.removeEventListener("message", this.boundOnMessageFromParent);
+  }
+  /**
+   * Called when an image has been generated. Posts the generated image to the parent via an 'imageGenerated' message.
+   *
+   * @param {string} generatedImage - the generated PNG image (as string)
+   * @returns {void}
+   */
+  static imageGenerated(t) {
+    v.postMessage({
+      payload: t,
+      messageType: "imageGenerated"
+    });
+  }
+}
+const ce = ({ viewVariables: e = {}, modelVariables: t = {} } = {}) => {
+  const i = (n, s, a = {}) => n ? Object.entries(n).reduce((r, [o, l]) => l.leaf ? (r[s ? `${s}.${o}` : o] = l, r) : i(l, `${s}${o === "value" ? "" : `.${o}`}`, r), a) : {};
+  return Object.assign(Object.assign({}, i(e, "view")), i(t, "model"));
+};
+class ue {
+  /**
+   * @param {KnimeService<T> | IFrameKnimeService} knimeService - knimeService instance which is used to communicate
+   *      with the framework.
+   */
+  constructor(t) {
+    this.knimeService = t;
+  }
+  /**
+   * @returns {FlowVariableSettings | null} - maps of model and view flow variables settings.
+   */
+  async getFlowVariableSettings() {
+    var t;
+    const i = await Promise.resolve(((t = this.knimeService.extensionConfig) === null || t === void 0 ? void 0 : t.flowVariableSettings) || {});
+    return ce(i);
+  }
+  /**
+   * @returns {boolean} - true, if the node this dialog belongs to also has a node view, otherwise false
+   */
+  hasNodeView() {
+    var t;
+    return (t = this.knimeService.extensionConfig) === null || t === void 0 ? void 0 : t.hasNodeView;
+  }
+}
+var L;
+(function(e) {
+  e.NUMERIC = "NUMERIC", e.NOMINAL = "NOMINAL";
+})(L || (L = {}));
+var he = {
+  aliceblue: [240, 248, 255],
+  antiquewhite: [250, 235, 215],
+  aqua: [0, 255, 255],
+  aquamarine: [127, 255, 212],
+  azure: [240, 255, 255],
+  beige: [245, 245, 220],
+  bisque: [255, 228, 196],
+  black: [0, 0, 0],
+  blanchedalmond: [255, 235, 205],
+  blue: [0, 0, 255],
+  blueviolet: [138, 43, 226],
+  brown: [165, 42, 42],
+  burlywood: [222, 184, 135],
+  cadetblue: [95, 158, 160],
+  chartreuse: [127, 255, 0],
+  chocolate: [210, 105, 30],
+  coral: [255, 127, 80],
+  cornflowerblue: [100, 149, 237],
+  cornsilk: [255, 248, 220],
+  crimson: [220, 20, 60],
+  cyan: [0, 255, 255],
+  darkblue: [0, 0, 139],
+  darkcyan: [0, 139, 139],
+  darkgoldenrod: [184, 134, 11],
+  darkgray: [169, 169, 169],
+  darkgreen: [0, 100, 0],
+  darkgrey: [169, 169, 169],
+  darkkhaki: [189, 183, 107],
+  darkmagenta: [139, 0, 139],
+  darkolivegreen: [85, 107, 47],
+  darkorange: [255, 140, 0],
+  darkorchid: [153, 50, 204],
+  darkred: [139, 0, 0],
+  darksalmon: [233, 150, 122],
+  darkseagreen: [143, 188, 143],
+  darkslateblue: [72, 61, 139],
+  darkslategray: [47, 79, 79],
+  darkslategrey: [47, 79, 79],
+  darkturquoise: [0, 206, 209],
+  darkviolet: [148, 0, 211],
+  deeppink: [255, 20, 147],
+  deepskyblue: [0, 191, 255],
+  dimgray: [105, 105, 105],
+  dimgrey: [105, 105, 105],
+  dodgerblue: [30, 144, 255],
+  firebrick: [178, 34, 34],
+  floralwhite: [255, 250, 240],
+  forestgreen: [34, 139, 34],
+  fuchsia: [255, 0, 255],
+  gainsboro: [220, 220, 220],
+  ghostwhite: [248, 248, 255],
+  gold: [255, 215, 0],
+  goldenrod: [218, 165, 32],
+  gray: [128, 128, 128],
+  green: [0, 128, 0],
+  greenyellow: [173, 255, 47],
+  grey: [128, 128, 128],
+  honeydew: [240, 255, 240],
+  hotpink: [255, 105, 180],
+  indianred: [205, 92, 92],
+  indigo: [75, 0, 130],
+  ivory: [255, 255, 240],
+  khaki: [240, 230, 140],
+  lavender: [230, 230, 250],
+  lavenderblush: [255, 240, 245],
+  lawngreen: [124, 252, 0],
+  lemonchiffon: [255, 250, 205],
+  lightblue: [173, 216, 230],
+  lightcoral: [240, 128, 128],
+  lightcyan: [224, 255, 255],
+  lightgoldenrodyellow: [250, 250, 210],
+  lightgray: [211, 211, 211],
+  lightgreen: [144, 238, 144],
+  lightgrey: [211, 211, 211],
+  lightpink: [255, 182, 193],
+  lightsalmon: [255, 160, 122],
+  lightseagreen: [32, 178, 170],
+  lightskyblue: [135, 206, 250],
+  lightslategray: [119, 136, 153],
+  lightslategrey: [119, 136, 153],
+  lightsteelblue: [176, 196, 222],
+  lightyellow: [255, 255, 224],
+  lime: [0, 255, 0],
+  limegreen: [50, 205, 50],
+  linen: [250, 240, 230],
+  magenta: [255, 0, 255],
+  maroon: [128, 0, 0],
+  mediumaquamarine: [102, 205, 170],
+  mediumblue: [0, 0, 205],
+  mediumorchid: [186, 85, 211],
+  mediumpurple: [147, 112, 219],
+  mediumseagreen: [60, 179, 113],
+  mediumslateblue: [123, 104, 238],
+  mediumspringgreen: [0, 250, 154],
+  mediumturquoise: [72, 209, 204],
+  mediumvioletred: [199, 21, 133],
+  midnightblue: [25, 25, 112],
+  mintcream: [245, 255, 250],
+  mistyrose: [255, 228, 225],
+  moccasin: [255, 228, 181],
+  navajowhite: [255, 222, 173],
+  navy: [0, 0, 128],
+  oldlace: [253, 245, 230],
+  olive: [128, 128, 0],
+  olivedrab: [107, 142, 35],
+  orange: [255, 165, 0],
+  orangered: [255, 69, 0],
+  orchid: [218, 112, 214],
+  palegoldenrod: [238, 232, 170],
+  palegreen: [152, 251, 152],
+  paleturquoise: [175, 238, 238],
+  palevioletred: [219, 112, 147],
+  papayawhip: [255, 239, 213],
+  peachpuff: [255, 218, 185],
+  peru: [205, 133, 63],
+  pink: [255, 192, 203],
+  plum: [221, 160, 221],
+  powderblue: [176, 224, 230],
+  purple: [128, 0, 128],
+  rebeccapurple: [102, 51, 153],
+  red: [255, 0, 0],
+  rosybrown: [188, 143, 143],
+  royalblue: [65, 105, 225],
+  saddlebrown: [139, 69, 19],
+  salmon: [250, 128, 114],
+  sandybrown: [244, 164, 96],
+  seagreen: [46, 139, 87],
+  seashell: [255, 245, 238],
+  sienna: [160, 82, 45],
+  silver: [192, 192, 192],
+  skyblue: [135, 206, 235],
+  slateblue: [106, 90, 205],
+  slategray: [112, 128, 144],
+  slategrey: [112, 128, 144],
+  snow: [255, 250, 250],
+  springgreen: [0, 255, 127],
+  steelblue: [70, 130, 180],
+  tan: [210, 180, 140],
+  teal: [0, 128, 128],
+  thistle: [216, 191, 216],
+  tomato: [255, 99, 71],
+  turquoise: [64, 224, 208],
+  violet: [238, 130, 238],
+  wheat: [245, 222, 179],
+  white: [255, 255, 255],
+  whitesmoke: [245, 245, 245],
+  yellow: [255, 255, 0],
+  yellowgreen: [154, 205, 50]
+};
+const z = he, V = {};
+for (const e of Object.keys(z))
+  V[z[e]] = e;
+const c = {
+  rgb: { channels: 3, labels: "rgb" },
+  hsl: { channels: 3, labels: "hsl" },
+  hsv: { channels: 3, labels: "hsv" },
+  hwb: { channels: 3, labels: "hwb" },
+  cmyk: { channels: 4, labels: "cmyk" },
+  xyz: { channels: 3, labels: "xyz" },
+  lab: { channels: 3, labels: "lab" },
+  lch: { channels: 3, labels: "lch" },
+  hex: { channels: 1, labels: ["hex"] },
+  keyword: { channels: 1, labels: ["keyword"] },
+  ansi16: { channels: 1, labels: ["ansi16"] },
+  ansi256: { channels: 1, labels: ["ansi256"] },
+  hcg: { channels: 3, labels: ["h", "c", "g"] },
+  apple: { channels: 3, labels: ["r16", "g16", "b16"] },
+  gray: { channels: 1, labels: ["gray"] }
+};
+var B = c;
+for (const e of Object.keys(c)) {
+  if (!("channels" in c[e]))
+    throw new Error("missing channels property: " + e);
+  if (!("labels" in c[e]))
+    throw new Error("missing channel labels property: " + e);
+  if (c[e].labels.length !== c[e].channels)
+    throw new Error("channel and label counts mismatch: " + e);
+  const { channels: t, labels: i } = c[e];
+  delete c[e].channels, delete c[e].labels, Object.defineProperty(c[e], "channels", { value: t }), Object.defineProperty(c[e], "labels", { value: i });
+}
+c.rgb.hsl = function(e) {
+  const t = e[0] / 255, i = e[1] / 255, n = e[2] / 255, s = Math.min(t, i, n), a = Math.max(t, i, n), r = a - s;
+  let o, l;
+  a === s ? o = 0 : t === a ? o = (i - n) / r : i === a ? o = 2 + (n - t) / r : n === a && (o = 4 + (t - i) / r), o = Math.min(o * 60, 360), o < 0 && (o += 360);
+  const u = (s + a) / 2;
+  return a === s ? l = 0 : u <= 0.5 ? l = r / (a + s) : l = r / (2 - a - s), [o, l * 100, u * 100];
+};
+c.rgb.hsv = function(e) {
+  let t, i, n, s, a;
+  const r = e[0] / 255, o = e[1] / 255, l = e[2] / 255, u = Math.max(r, o, l), d = u - Math.min(r, o, l), h = function(H) {
+    return (u - H) / 6 / d + 1 / 2;
+  };
+  return d === 0 ? (s = 0, a = 0) : (a = d / u, t = h(r), i = h(o), n = h(l), r === u ? s = n - i : o === u ? s = 1 / 3 + t - n : l === u && (s = 2 / 3 + i - t), s < 0 ? s += 1 : s > 1 && (s -= 1)), [
+    s * 360,
+    a * 100,
+    u * 100
+  ];
+};
+c.rgb.hwb = function(e) {
+  const t = e[0], i = e[1];
+  let n = e[2];
+  const s = c.rgb.hsl(e)[0], a = 1 / 255 * Math.min(t, Math.min(i, n));
+  return n = 1 - 1 / 255 * Math.max(t, Math.max(i, n)), [s, a * 100, n * 100];
+};
+c.rgb.cmyk = function(e) {
+  const t = e[0] / 255, i = e[1] / 255, n = e[2] / 255, s = Math.min(1 - t, 1 - i, 1 - n), a = (1 - t - s) / (1 - s) || 0, r = (1 - i - s) / (1 - s) || 0, o = (1 - n - s) / (1 - s) || 0;
+  return [a * 100, r * 100, o * 100, s * 100];
+};
+function de(e, t) {
+  return (e[0] - t[0]) ** 2 + (e[1] - t[1]) ** 2 + (e[2] - t[2]) ** 2;
+}
+c.rgb.keyword = function(e) {
+  const t = V[e];
+  if (t)
+    return t;
+  let i = 1 / 0, n;
+  for (const s of Object.keys(z)) {
+    const a = z[s], r = de(e, a);
+    r < i && (i = r, n = s);
+  }
+  return n;
+};
+c.keyword.rgb = function(e) {
+  return z[e];
+};
+c.rgb.xyz = function(e) {
+  let t = e[0] / 255, i = e[1] / 255, n = e[2] / 255;
+  t = t > 0.04045 ? ((t + 0.055) / 1.055) ** 2.4 : t / 12.92, i = i > 0.04045 ? ((i + 0.055) / 1.055) ** 2.4 : i / 12.92, n = n > 0.04045 ? ((n + 0.055) / 1.055) ** 2.4 : n / 12.92;
+  const s = t * 0.4124 + i * 0.3576 + n * 0.1805, a = t * 0.2126 + i * 0.7152 + n * 0.0722, r = t * 0.0193 + i * 0.1192 + n * 0.9505;
+  return [s * 100, a * 100, r * 100];
+};
+c.rgb.lab = function(e) {
+  const t = c.rgb.xyz(e);
+  let i = t[0], n = t[1], s = t[2];
+  i /= 95.047, n /= 100, s /= 108.883, i = i > 8856e-6 ? i ** (1 / 3) : 7.787 * i + 16 / 116, n = n > 8856e-6 ? n ** (1 / 3) : 7.787 * n + 16 / 116, s = s > 8856e-6 ? s ** (1 / 3) : 7.787 * s + 16 / 116;
+  const a = 116 * n - 16, r = 500 * (i - n), o = 200 * (n - s);
+  return [a, r, o];
+};
+c.hsl.rgb = function(e) {
+  const t = e[0] / 360, i = e[1] / 100, n = e[2] / 100;
+  let s, a, r;
+  if (i === 0)
+    return r = n * 255, [r, r, r];
+  n < 0.5 ? s = n * (1 + i) : s = n + i - n * i;
+  const o = 2 * n - s, l = [0, 0, 0];
+  for (let u = 0; u < 3; u++)
+    a = t + 1 / 3 * -(u - 1), a < 0 && a++, a > 1 && a--, 6 * a < 1 ? r = o + (s - o) * 6 * a : 2 * a < 1 ? r = s : 3 * a < 2 ? r = o + (s - o) * (2 / 3 - a) * 6 : r = o, l[u] = r * 255;
+  return l;
+};
+c.hsl.hsv = function(e) {
+  const t = e[0];
+  let i = e[1] / 100, n = e[2] / 100, s = i;
+  const a = Math.max(n, 0.01);
+  n *= 2, i *= n <= 1 ? n : 2 - n, s *= a <= 1 ? a : 2 - a;
+  const r = (n + i) / 2, o = n === 0 ? 2 * s / (a + s) : 2 * i / (n + i);
+  return [t, o * 100, r * 100];
+};
+c.hsv.rgb = function(e) {
+  const t = e[0] / 60, i = e[1] / 100;
+  let n = e[2] / 100;
+  const s = Math.floor(t) % 6, a = t - Math.floor(t), r = 255 * n * (1 - i), o = 255 * n * (1 - i * a), l = 255 * n * (1 - i * (1 - a));
+  switch (n *= 255, s) {
+    case 0:
+      return [n, l, r];
+    case 1:
+      return [o, n, r];
+    case 2:
+      return [r, n, l];
+    case 3:
+      return [r, o, n];
+    case 4:
+      return [l, r, n];
+    case 5:
+      return [n, r, o];
+  }
+};
+c.hsv.hsl = function(e) {
+  const t = e[0], i = e[1] / 100, n = e[2] / 100, s = Math.max(n, 0.01);
+  let a, r;
+  r = (2 - i) * n;
+  const o = (2 - i) * s;
+  return a = i * s, a /= o <= 1 ? o : 2 - o, a = a || 0, r /= 2, [t, a * 100, r * 100];
+};
+c.hwb.rgb = function(e) {
+  const t = e[0] / 360;
+  let i = e[1] / 100, n = e[2] / 100;
+  const s = i + n;
+  let a;
+  s > 1 && (i /= s, n /= s);
+  const r = Math.floor(6 * t), o = 1 - n;
+  a = 6 * t - r, r & 1 && (a = 1 - a);
+  const l = i + a * (o - i);
+  let u, d, h;
+  switch (r) {
+    default:
+    case 6:
+    case 0:
+      u = o, d = l, h = i;
+      break;
+    case 1:
+      u = l, d = o, h = i;
+      break;
+    case 2:
+      u = i, d = o, h = l;
+      break;
+    case 3:
+      u = i, d = l, h = o;
+      break;
+    case 4:
+      u = l, d = i, h = o;
+      break;
+    case 5:
+      u = o, d = i, h = l;
+      break;
+  }
+  return [u * 255, d * 255, h * 255];
+};
+c.cmyk.rgb = function(e) {
+  const t = e[0] / 100, i = e[1] / 100, n = e[2] / 100, s = e[3] / 100, a = 1 - Math.min(1, t * (1 - s) + s), r = 1 - Math.min(1, i * (1 - s) + s), o = 1 - Math.min(1, n * (1 - s) + s);
+  return [a * 255, r * 255, o * 255];
+};
+c.xyz.rgb = function(e) {
+  const t = e[0] / 100, i = e[1] / 100, n = e[2] / 100;
+  let s, a, r;
+  return s = t * 3.2406 + i * -1.5372 + n * -0.4986, a = t * -0.9689 + i * 1.8758 + n * 0.0415, r = t * 0.0557 + i * -0.204 + n * 1.057, s = s > 31308e-7 ? 1.055 * s ** (1 / 2.4) - 0.055 : s * 12.92, a = a > 31308e-7 ? 1.055 * a ** (1 / 2.4) - 0.055 : a * 12.92, r = r > 31308e-7 ? 1.055 * r ** (1 / 2.4) - 0.055 : r * 12.92, s = Math.min(Math.max(0, s), 1), a = Math.min(Math.max(0, a), 1), r = Math.min(Math.max(0, r), 1), [s * 255, a * 255, r * 255];
+};
+c.xyz.lab = function(e) {
+  let t = e[0], i = e[1], n = e[2];
+  t /= 95.047, i /= 100, n /= 108.883, t = t > 8856e-6 ? t ** (1 / 3) : 7.787 * t + 16 / 116, i = i > 8856e-6 ? i ** (1 / 3) : 7.787 * i + 16 / 116, n = n > 8856e-6 ? n ** (1 / 3) : 7.787 * n + 16 / 116;
+  const s = 116 * i - 16, a = 500 * (t - i), r = 200 * (i - n);
+  return [s, a, r];
+};
+c.lab.xyz = function(e) {
+  const t = e[0], i = e[1], n = e[2];
+  let s, a, r;
+  a = (t + 16) / 116, s = i / 500 + a, r = a - n / 200;
+  const o = a ** 3, l = s ** 3, u = r ** 3;
+  return a = o > 8856e-6 ? o : (a - 16 / 116) / 7.787, s = l > 8856e-6 ? l : (s - 16 / 116) / 7.787, r = u > 8856e-6 ? u : (r - 16 / 116) / 7.787, s *= 95.047, a *= 100, r *= 108.883, [s, a, r];
+};
+c.lab.lch = function(e) {
+  const t = e[0], i = e[1], n = e[2];
+  let s;
+  s = Math.atan2(n, i) * 360 / 2 / Math.PI, s < 0 && (s += 360);
+  const r = Math.sqrt(i * i + n * n);
+  return [t, r, s];
+};
+c.lch.lab = function(e) {
+  const t = e[0], i = e[1], s = e[2] / 360 * 2 * Math.PI, a = i * Math.cos(s), r = i * Math.sin(s);
+  return [t, a, r];
+};
+c.rgb.ansi16 = function(e, t = null) {
+  const [i, n, s] = e;
+  let a = t === null ? c.rgb.hsv(e)[2] : t;
+  if (a = Math.round(a / 50), a === 0)
+    return 30;
+  let r = 30 + (Math.round(s / 255) << 2 | Math.round(n / 255) << 1 | Math.round(i / 255));
+  return a === 2 && (r += 60), r;
+};
+c.hsv.ansi16 = function(e) {
+  return c.rgb.ansi16(c.hsv.rgb(e), e[2]);
+};
+c.rgb.ansi256 = function(e) {
+  const t = e[0], i = e[1], n = e[2];
+  return t === i && i === n ? t < 8 ? 16 : t > 248 ? 231 : Math.round((t - 8) / 247 * 24) + 232 : 16 + 36 * Math.round(t / 255 * 5) + 6 * Math.round(i / 255 * 5) + Math.round(n / 255 * 5);
+};
+c.ansi16.rgb = function(e) {
+  let t = e % 10;
+  if (t === 0 || t === 7)
+    return e > 50 && (t += 3.5), t = t / 10.5 * 255, [t, t, t];
+  const i = (~~(e > 50) + 1) * 0.5, n = (t & 1) * i * 255, s = (t >> 1 & 1) * i * 255, a = (t >> 2 & 1) * i * 255;
+  return [n, s, a];
+};
+c.ansi256.rgb = function(e) {
+  if (e >= 232) {
+    const a = (e - 232) * 10 + 8;
+    return [a, a, a];
+  }
+  e -= 16;
+  let t;
+  const i = Math.floor(e / 36) / 5 * 255, n = Math.floor((t = e % 36) / 6) / 5 * 255, s = t % 6 / 5 * 255;
+  return [i, n, s];
+};
+c.rgb.hex = function(e) {
+  const i = (((Math.round(e[0]) & 255) << 16) + ((Math.round(e[1]) & 255) << 8) + (Math.round(e[2]) & 255)).toString(16).toUpperCase();
+  return "000000".substring(i.length) + i;
+};
+c.hex.rgb = function(e) {
+  const t = e.toString(16).match(/[a-f0-9]{6}|[a-f0-9]{3}/i);
+  if (!t)
+    return [0, 0, 0];
+  let i = t[0];
+  t[0].length === 3 && (i = i.split("").map((o) => o + o).join(""));
+  const n = parseInt(i, 16), s = n >> 16 & 255, a = n >> 8 & 255, r = n & 255;
+  return [s, a, r];
+};
+c.rgb.hcg = function(e) {
+  const t = e[0] / 255, i = e[1] / 255, n = e[2] / 255, s = Math.max(Math.max(t, i), n), a = Math.min(Math.min(t, i), n), r = s - a;
+  let o, l;
+  return r < 1 ? o = a / (1 - r) : o = 0, r <= 0 ? l = 0 : s === t ? l = (i - n) / r % 6 : s === i ? l = 2 + (n - t) / r : l = 4 + (t - i) / r, l /= 6, l %= 1, [l * 360, r * 100, o * 100];
+};
+c.hsl.hcg = function(e) {
+  const t = e[1] / 100, i = e[2] / 100, n = i < 0.5 ? 2 * t * i : 2 * t * (1 - i);
+  let s = 0;
+  return n < 1 && (s = (i - 0.5 * n) / (1 - n)), [e[0], n * 100, s * 100];
+};
+c.hsv.hcg = function(e) {
+  const t = e[1] / 100, i = e[2] / 100, n = t * i;
+  let s = 0;
+  return n < 1 && (s = (i - n) / (1 - n)), [e[0], n * 100, s * 100];
+};
+c.hcg.rgb = function(e) {
+  const t = e[0] / 360, i = e[1] / 100, n = e[2] / 100;
+  if (i === 0)
+    return [n * 255, n * 255, n * 255];
+  const s = [0, 0, 0], a = t % 1 * 6, r = a % 1, o = 1 - r;
+  let l = 0;
+  switch (Math.floor(a)) {
+    case 0:
+      s[0] = 1, s[1] = r, s[2] = 0;
+      break;
+    case 1:
+      s[0] = o, s[1] = 1, s[2] = 0;
+      break;
+    case 2:
+      s[0] = 0, s[1] = 1, s[2] = r;
+      break;
+    case 3:
+      s[0] = 0, s[1] = o, s[2] = 1;
+      break;
+    case 4:
+      s[0] = r, s[1] = 0, s[2] = 1;
+      break;
+    default:
+      s[0] = 1, s[1] = 0, s[2] = o;
+  }
+  return l = (1 - i) * n, [
+    (i * s[0] + l) * 255,
+    (i * s[1] + l) * 255,
+    (i * s[2] + l) * 255
+  ];
+};
+c.hcg.hsv = function(e) {
+  const t = e[1] / 100, i = e[2] / 100, n = t + i * (1 - t);
+  let s = 0;
+  return n > 0 && (s = t / n), [e[0], s * 100, n * 100];
+};
+c.hcg.hsl = function(e) {
+  const t = e[1] / 100, n = e[2] / 100 * (1 - t) + 0.5 * t;
+  let s = 0;
+  return n > 0 && n < 0.5 ? s = t / (2 * n) : n >= 0.5 && n < 1 && (s = t / (2 * (1 - n))), [e[0], s * 100, n * 100];
+};
+c.hcg.hwb = function(e) {
+  const t = e[1] / 100, i = e[2] / 100, n = t + i * (1 - t);
+  return [e[0], (n - t) * 100, (1 - n) * 100];
+};
+c.hwb.hcg = function(e) {
+  const t = e[1] / 100, n = 1 - e[2] / 100, s = n - t;
+  let a = 0;
+  return s < 1 && (a = (n - s) / (1 - s)), [e[0], s * 100, a * 100];
+};
+c.apple.rgb = function(e) {
+  return [e[0] / 65535 * 255, e[1] / 65535 * 255, e[2] / 65535 * 255];
+};
+c.rgb.apple = function(e) {
+  return [e[0] / 255 * 65535, e[1] / 255 * 65535, e[2] / 255 * 65535];
+};
+c.gray.rgb = function(e) {
+  return [e[0] / 100 * 255, e[0] / 100 * 255, e[0] / 100 * 255];
+};
+c.gray.hsl = function(e) {
+  return [0, 0, e[0]];
+};
+c.gray.hsv = c.gray.hsl;
+c.gray.hwb = function(e) {
+  return [0, 100, e[0]];
+};
+c.gray.cmyk = function(e) {
+  return [0, 0, 0, e[0]];
+};
+c.gray.lab = function(e) {
+  return [e[0], 0, 0];
+};
+c.gray.hex = function(e) {
+  const t = Math.round(e[0] / 100 * 255) & 255, n = ((t << 16) + (t << 8) + t).toString(16).toUpperCase();
+  return "000000".substring(n.length) + n;
+};
+c.rgb.gray = function(e) {
+  return [(e[0] + e[1] + e[2]) / 3 / 255 * 100];
+};
+const k = B;
+function pe() {
+  const e = {}, t = Object.keys(k);
+  for (let i = t.length, n = 0; n < i; n++)
+    e[t[n]] = {
+      // http://jsperf.com/1-vs-infinity
+      // micro-opt, but this is simple.
+      distance: -1,
+      parent: null
+    };
+  return e;
+}
+function me(e) {
+  const t = pe(), i = [e];
+  for (t[e].distance = 0; i.length; ) {
+    const n = i.pop(), s = Object.keys(k[n]);
+    for (let a = s.length, r = 0; r < a; r++) {
+      const o = s[r], l = t[o];
+      l.distance === -1 && (l.distance = t[n].distance + 1, l.parent = n, i.unshift(o));
+    }
+  }
+  return t;
+}
+function fe(e, t) {
+  return function(i) {
+    return t(e(i));
+  };
+}
+function ve(e, t) {
+  const i = [t[e].parent, e];
+  let n = k[t[e].parent][e], s = t[e].parent;
+  for (; t[s].parent; )
+    i.unshift(t[s].parent), n = fe(k[t[s].parent][s], n), s = t[s].parent;
+  return n.conversion = i, n;
+}
+var ge = function(e) {
+  const t = me(e), i = {}, n = Object.keys(t);
+  for (let s = n.length, a = 0; a < s; a++) {
+    const r = n[a];
+    t[r].parent !== null && (i[r] = ve(r, t));
+  }
+  return i;
+};
+const R = B, Se = ge, S = {}, be = Object.keys(R);
+function ze(e) {
+  const t = function(...i) {
+    const n = i[0];
+    return n == null ? n : (n.length > 1 && (i = n), e(i));
+  };
+  return "conversion" in e && (t.conversion = e.conversion), t;
+}
+function Pe(e) {
+  const t = function(...i) {
+    const n = i[0];
+    if (n == null)
+      return n;
+    n.length > 1 && (i = n);
+    const s = e(i);
+    if (typeof s == "object")
+      for (let a = s.length, r = 0; r < a; r++)
+        s[r] = Math.round(s[r]);
+    return s;
+  };
+  return "conversion" in e && (t.conversion = e.conversion), t;
+}
+be.forEach((e) => {
+  S[e] = {}, Object.defineProperty(S[e], "channels", { value: R[e].channels }), Object.defineProperty(S[e], "labels", { value: R[e].labels });
+  const t = Se(e);
+  Object.keys(t).forEach((n) => {
+    const s = t[n];
+    S[e][n] = Pe(s), S[e][n].raw = ze(s);
+  });
+});
+Object.assign({
+  generateRequestId: O,
+  createJsonRpcRequest: F
+}, le);
+class ye {
+  constructor() {
+    f(this, "_knimeService");
+    f(this, "_jsonDataService");
+    f(this, "_dialogService");
+    f(this, "_settings", null);
+    f(this, "_eventHandlers", {});
+    f(this, "_runEventPoller", !0);
+    const t = async () => {
+      const s = new v();
+      return await s.waitForInitialization(), s;
+    };
+    this._knimeService = t();
+    const i = async () => {
+      const s = await this._knimeService, a = new oe(s);
+      return a.registerDataGetter(() => this._settings), a;
+    };
+    this._jsonDataService = i();
+    const n = async () => {
+      const s = await this._knimeService;
+      return new ue(s);
+    };
+    this._dialogService = n(), this.eventPoller();
+  }
+  async eventPoller() {
+    for (; this._runEventPoller; ) {
+      const t = await this.sendToService("getEvent");
+      if (t)
+        if (t.type in this._eventHandlers)
+          this._eventHandlers[t.type](t.data);
+        else
+          throw new Error(
+            `Got unexpected event from Java with type ${t.type}`
+          );
+    }
+  }
+  stopEventPoller() {
+    this._runEventPoller = !1;
+  }
+  async sendToService(t, i) {
+    return (await this._jsonDataService).data({
+      method: t,
+      options: i
+    });
+  }
+  async getInitialSettings() {
+    return (await this._jsonDataService).initialData();
+  }
+  async getFlowVariableSettings() {
+    return (await this._dialogService).getFlowVariableSettings();
+  }
+  async saveSettings(t) {
+    this._settings = t, (await this._jsonDataService).applyData();
+  }
+  registerEventHandler(t, i) {
+    this._eventHandlers[t] = i;
+  }
+  registerLanguageServerEventHandler(t) {
+    this.registerEventHandler("language-server", t);
+  }
+  registerConsoleEventHandler(t) {
+    this.registerEventHandler("console", t);
+  }
+}
+let P;
+const Ee = (e) => (typeof P > "u" && (typeof e > "u" ? P = new ye() : P = e), P), we = /* @__PURE__ */ q({
+  __name: "CodeEditor",
+  props: {
     language: {
       type: String,
       default: null
@@ -18,19 +1498,22 @@ const p = /* @__PURE__ */ l({
     }
   },
   emits: ["monaco-created"],
-  setup(r, { emit: n }) {
-    const e = r, t = c(null);
-    return d(() => {
-      if (t.value === null)
+  setup(e, { emit: t }) {
+    const i = e;
+    let n, s;
+    const a = Y(null);
+    return Q(async () => {
+      if (a.value === null)
         throw new Error(
           "Editor reference is null. This is an implementation error"
         );
-      const o = i.editor.createModel(
-        e.initialScript,
-        e.language,
-        i.Uri.parse(`inmemory://${e.fileName}`)
-      ), a = i.editor.create(t.value, {
-        model: o,
+      const r = (await Ee().getInitialSettings()).script;
+      n = C.editor.createModel(
+        r,
+        i.language,
+        C.Uri.parse(`inmemory://${i.fileName}`)
+      ), s = C.editor.create(a.value, {
+        model: n,
         glyphMargin: !1,
         lightbulb: {
           enabled: !0
@@ -39,21 +1522,223 @@ const p = /* @__PURE__ */ l({
         automaticLayout: !0,
         scrollBeyondLastLine: !0,
         fixedOverflowWidgets: !0
-      });
-      n("monaco-created", { editor: a, editorModel: o });
-    }), (o, a) => (s(), u("div", {
+      }), t("monaco-created", { editor: s, editorModel: n });
+    }), Z(() => {
+      typeof n < "u" && n.dispose(), typeof s < "u" && s.dispose();
+    }), (r, o) => (D(), N("div", {
       ref_key: "editorRef",
-      ref: t,
+      ref: a,
       class: "code-editor"
     }, null, 512));
   }
 });
-const f = (r, n) => {
-  const e = r.__vccOpts || r;
-  for (const [t, o] of n)
-    e[t] = o;
-  return e;
-}, _ = /* @__PURE__ */ f(p, [["__scopeId", "data-v-6ef3894e"]]);
+const G = (e, t) => {
+  const i = e.__vccOpts || e;
+  for (const [n, s] of t)
+    i[n] = s;
+  return i;
+}, ke = /* @__PURE__ */ G(we, [["__scopeId", "data-v-2a674232"]]), xe = q({
+  name: "ScriptingEditor",
+  components: {
+    Splitpanes: ee,
+    Pane: se,
+    CodeEditor: ke
+  },
+  props: {
+    language: {
+      type: String,
+      default: null
+    },
+    fileName: {
+      type: String,
+      default: null
+    },
+    rightPaneLayout: {
+      type: String,
+      default: "fixed"
+    }
+  },
+  emits: ["monaco-created"],
+  data() {
+    return {
+      currentPaneSizes: {
+        left: 20,
+        right: 25,
+        bottom: 30
+      },
+      initialPaneSizes: {
+        left: 20,
+        right: 25,
+        bottom: 30
+      },
+      previousPaneSizes: {
+        left: 20,
+        right: 25,
+        bottom: 30
+      }
+    };
+  },
+  computed: {
+    usedMainPaneSize() {
+      return 100 - this.currentPaneSizes.left;
+    },
+    usedHorizontalCodeEditorPaneSize() {
+      return 100 - this.currentPaneSizes.right;
+    },
+    usedVerticalCodeEditorPaneSize() {
+      return 100 - this.currentPaneSizes.bottom;
+    },
+    isLeftPaneCollapsed() {
+      return this.currentPaneSizes.left === 0;
+    },
+    isRightPaneCollapsed() {
+      return this.currentPaneSizes.right === 0;
+    },
+    isBottomPaneCollapsed() {
+      return this.currentPaneSizes.bottom === 0;
+    }
+  },
+  methods: {
+    collapsePane(e) {
+      let t = this.currentPaneSizes[e] === 0 ? this.previousPaneSizes[e] : 0;
+      e === "left" && this.updateRightPane(t), this.resizePane(t, e);
+    },
+    resizePane(e, t, i = !0) {
+      this.currentPaneSizes[t] = e, i && this.updatePreviousPaneSize(t);
+    },
+    updatePreviousPaneSize(e) {
+      this.currentPaneSizes[e] <= 0 || (this.previousPaneSizes[e] = this.currentPaneSizes[e]);
+    },
+    updateRightPane(e) {
+      if (this.rightPaneLayout !== "fixed" || this.currentPaneSizes.right <= 0)
+        return;
+      const t = 100 - e, n = (100 - this.currentPaneSizes.left) * (this.previousPaneSizes.right / 100) / t * 100;
+      this.resizePane(n, "right", !1);
+    },
+    onMonacoCreated({
+      editor: e,
+      editorModel: t
+    }) {
+      this.$emit("monaco-created", { editor: e, editorModel: t });
+    }
+  }
+});
+const Me = { class: "layout" };
+function Ce(e, t, i, n, s, a) {
+  const r = x("pane"), o = x("CodeEditor"), l = x("splitpanes");
+  return D(), N("div", Me, [
+    p(l, {
+      ref: "mainSplitpane",
+      class: M(["common-splitter unset-transition", {
+        "left-facing-splitter": !e.isLeftPaneCollapsed,
+        "right-facing-splitter": e.isLeftPaneCollapsed
+      }]),
+      "dbl-click-splitter": !1,
+      onSplitterClick: t[4] || (t[4] = (u) => {
+        e.collapsePane("left"), e.updatePreviousPaneSize("right");
+      }),
+      onResize: t[5] || (t[5] = (u) => e.updateRightPane(u[0].size)),
+      onResized: t[6] || (t[6] = (u) => {
+        e.resizePane(u[0].size, "left"), e.updatePreviousPaneSize("right");
+      })
+    }, {
+      default: m(() => [
+        p(r, {
+          ref: "leftPane",
+          size: e.currentPaneSizes.left
+        }, {
+          default: m(() => [
+            y(e.$slots, "leftPane", {}, void 0, !0)
+          ]),
+          _: 3
+        }, 8, ["size"]),
+        p(r, {
+          ref: "mainPane",
+          size: e.usedMainPaneSize,
+          "min-size": "40"
+        }, {
+          default: m(() => [
+            p(l, {
+              ref: "horizontalSplitpane",
+              horizontal: "",
+              class: M(["common-splitter", {
+                "down-facing-splitter": !e.isBottomPaneCollapsed,
+                "up-facing-splitter": e.isBottomPaneCollapsed
+              }]),
+              "dbl-click-splitter": !1,
+              onSplitterClick: t[2] || (t[2] = (u) => e.collapsePane("bottom")),
+              onResized: t[3] || (t[3] = (u) => e.resizePane(u[1].size, "bottom"))
+            }, {
+              default: m(() => [
+                p(r, {
+                  ref: "topPane",
+                  size: e.usedVerticalCodeEditorPaneSize,
+                  "min-size": "20"
+                }, {
+                  default: m(() => [
+                    p(l, {
+                      ref: "verticalSplitpane",
+                      class: M(["common-splitter unset-transition", {
+                        "left-facing-splitter": e.isRightPaneCollapsed,
+                        "right-facing-splitter": !e.isRightPaneCollapsed
+                      }]),
+                      "dbl-click-splitter": !1,
+                      onSplitterClick: t[0] || (t[0] = (u) => e.collapsePane("right")),
+                      onResized: t[1] || (t[1] = (u) => e.resizePane(u[1].size, "right"))
+                    }, {
+                      default: m(() => [
+                        p(r, {
+                          ref: "editorPane",
+                          size: e.usedHorizontalCodeEditorPaneSize,
+                          "min-size": "25"
+                        }, {
+                          default: m(() => [
+                            p(o, {
+                              language: e.language,
+                              "file-name": e.fileName,
+                              onMonacoCreated: e.onMonacoCreated
+                            }, null, 8, ["language", "file-name", "onMonacoCreated"])
+                          ]),
+                          _: 1
+                        }, 8, ["size"]),
+                        p(r, {
+                          ref: "rightPane",
+                          size: e.currentPaneSizes.right
+                        }, {
+                          default: m(() => [
+                            y(e.$slots, "rightPane", {}, void 0, !0)
+                          ]),
+                          _: 3
+                        }, 8, ["size"])
+                      ]),
+                      _: 3
+                    }, 8, ["class"])
+                  ]),
+                  _: 3
+                }, 8, ["size"]),
+                p(r, {
+                  ref: "bottomPane",
+                  size: e.currentPaneSizes.bottom
+                }, {
+                  default: m(() => [
+                    y(e.$slots, "bottomPane", {}, void 0, !0)
+                  ]),
+                  _: 3
+                }, 8, ["size"])
+              ]),
+              _: 3
+            }, 8, ["class"])
+          ]),
+          _: 3
+        }, 8, ["size"])
+      ]),
+      _: 3
+    }, 8, ["class"])
+  ]);
+}
+const De = /* @__PURE__ */ G(xe, [["render", Ce], ["__scopeId", "data-v-52dc9a8f"]]);
 export {
-  _ as CodeEditor
+  ke as CodeEditor,
+  De as ScriptingEditor,
+  Ee as getScriptingService
 };