@versa-stack/v-craft 0.0.1

package/dist/v-craft.es.js

@@ -0,0 +1,3027 @@
+import { defineComponent as $, useSlots as Ue, useAttrs as ot, inject as ae, computed as w, openBlock as v, createBlock as N, resolveDynamicComponent as me, normalizeProps as Ae, mergeProps as Oe, unref as f, createSlots as ge, renderList as M, withCtx as X, renderSlot as W, guardReactiveProps as it, createCommentVNode as x, markRaw as Be, ref as K, watch as le, normalizeClass as oe, createTextVNode as at, toDisplayString as ne, createElementBlock as E, withKeys as Pe, withModifiers as V, nextTick as ue, provide as re, resolveComponent as U, createVNode as G, Fragment as T, createElementVNode as O, toRef as ce, onUnmounted as Le, toRefs as fe, normalizeStyle as je, withDirectives as lt, Teleport as ut, vShow as ct, onMounted as Ne, onBeforeMount as dt, onBeforeUnmount as ft, readonly as ht, toHandlers as Fe, h as pt } from "vue";
+import { defineStore as He, storeToRefs as Z } from "pinia";
+import { v4 as de } from "uuid";
+import { debounce as Ve } from "lodash-es";
+import { FormKit as Ke, FormKitSchema as Xe } from "@formkit/vue";
+const vt = /* @__PURE__ */ $({
+  name: "CraftCanvas",
+  __name: "CraftCanvas",
+  props: {
+    componentName: {}
+  },
+  setup(t) {
+    const e = Ue(), r = ot(), n = t, s = ae("resolver"), o = w(() => s?.value.resolve(n.componentName)), i = w(() => o.value?.componentName || n.componentName);
+    return (a, c) => i.value ? (v(), N(me(i.value), Ae(Oe({ key: 0 }, f(r))), ge({ _: 2 }, [
+      M(f(e), (u, d) => ({
+        name: d,
+        fn: X((h) => [
+          W(a.$slots, d, Ae(it(h || {})))
+        ])
+      }))
+    ]), 1040)) : x("", !0);
+  }
+}), xe = (t) => {
+  const e = ae("resolver"), r = w(() => !e || !t?.value ? {} : e.value.resolve(
+    t.value.componentName
+  )), n = w(() => r.value?.defaultProps || {});
+  return {
+    resolvedNode: r,
+    resolver: e,
+    defaultProps: n
+  };
+}, mt = () => {
+  const t = ae("craftNode");
+  if (!t)
+    throw new Error("craftNode or resolver not provided");
+  const { resolver: e, resolvedNode: r, defaultProps: n } = xe(t);
+  return {
+    craftNode: t,
+    resolver: e,
+    resolvedNode: r,
+    defaultProps: n
+  };
+}, ze = (t) => t.visible === void 0 || t.visible, gt = (t) => {
+  let e = t;
+  const r = j();
+  for (; e.parentUuid; )
+    if (e = r.nodeMap.get(e.parentUuid), q(e))
+      return !0;
+  return !1;
+}, yt = (t) => gt(t) ? t.rules?.canDrag ? t.rules.canDrag(t) : !0 : !1, qe = (t, e) => {
+  const r = j();
+  let n = e;
+  for (; n?.parentUuid; ) {
+    if (n.parentUuid === t.uuid)
+      return !0;
+    n = r.nodeMap.get(n.parentUuid);
+  }
+  return !1;
+}, te = (t) => t.componentName === "CraftCanvas" ? t.props.componentName : t.componentName, ie = (t, e, r) => {
+  if (!q(e) || t.uuid === e.uuid)
+    return !1;
+  const n = r.resolve(te(e)), s = r.resolve(te(t)), o = n?.rules || {}, i = s?.rules || {};
+  if (t.parentUuid) {
+    const c = j().nodeMap.get(t.parentUuid), u = r.resolve(te(c))?.rules || {};
+    if (u.canMoveOut && !u.canMoveOut(t, e, r))
+      return;
+  }
+  return !(i.canMoveInto && !i.canMoveInto(t, e, r) || qe(t, e) || o.canMoveIn && !o.canMoveIn(t, e, r));
+}, q = (t) => t.componentName === "CraftCanvas", pe = (t, e, r) => {
+  const n = j();
+  return e.uuid === t.uuid || !e.parentUuid ? !1 : ie(
+    t,
+    n.nodeMap.get(e.parentUuid),
+    r
+  );
+}, We = (t) => (t.uuid || (t.uuid = de()), t.slots && Object.values(t.slots).forEach((e) => {
+  e.forEach((r) => (r.uuid || (r.uuid = de()), r.parentUuid !== t.uuid && (r.parentUuid = t.uuid), We(r), r));
+}), t), j = He("editor", {
+  state: () => ({
+    nodeMap: /* @__PURE__ */ new Map(),
+    rootNodes: [],
+    selectedUuid: null,
+    draggedNode: null,
+    enabled: !1,
+    nodeRefsRecord: {},
+    resolver: null,
+    eventsContext: {},
+    nodeDataMap: {},
+    draggingDisabled: !1
+  }),
+  actions: {
+    clear() {
+      this.nodeMap.clear(), this.rootNodes = [], this.selectedUuid = null, this.draggedNode = null, this.nodeRefsRecord = {}, this.draggingDisabled = !1;
+    },
+    enable() {
+      this.enabled = !0;
+    },
+    disable() {
+      this.enabled = !1;
+    },
+    disableDragging() {
+      this.draggingDisabled = !0;
+    },
+    enableDragging() {
+      this.draggingDisabled = !1;
+    },
+    setResolver(t) {
+      this.resolver = t;
+    },
+    setNodeRef(t, e) {
+      this.nodeRefsRecord[t.uuid] = e;
+    },
+    toggleNodeVisibility(t) {
+      const e = this.nodeMap.get(t.uuid);
+      if (e) {
+        if (e.visible = !ze(e), e.slots) {
+          const r = (n) => (n.visible = e.visible, n.slots && Object.values(n.slots).forEach((s) => {
+            s.forEach((o) => r(o));
+          }), this.nodeMap.set(n.uuid, n), n);
+          Object.values(e.slots).forEach((n) => {
+            n.forEach((s) => r(s));
+          });
+        }
+        this.nodeMap.set(e.uuid, e);
+      }
+    },
+    setNodeData(t, e) {
+      this.nodeDataMap[t] = e;
+    },
+    updateNodeProps(t, e) {
+      const r = this.nodeMap.get(t);
+      r && Object.assign(r.props, e);
+    },
+    updateNodeEvents(t, e) {
+      const r = this.nodeMap.get(t);
+      r && (r.events || (r.events = {}), Object.assign(r.events, e));
+    },
+    setNodes(t) {
+      this.clear(), this.rootNodes = [];
+      const e = (r) => {
+        this.nodeMap.set(r.uuid, { ...r, slots: {} }), r.parentUuid || this.rootNodes.push(r.uuid), r.slots && Object.entries(r.slots).forEach(([n, s]) => {
+          s.forEach((o) => {
+            o.parentUuid = r.uuid, e(o), this.nodeMap.get(r.uuid).slots[n] || (this.nodeMap.get(r.uuid).slots[n] = []), this.nodeMap.get(r.uuid).slots[n].push(o);
+          });
+        });
+      };
+      t.forEach(e);
+    },
+    addNodeRecursively(t, e = null) {
+      const r = t.uuid || de(), n = { ...t, uuid: r, parentUuid: e };
+      this.nodeMap.set(r, Be(n)), e || this.rootNodes.push(r), t.slots && Object.values(t.slots).forEach((s) => {
+        s.forEach((o) => this.addNodeRecursively(o, r));
+      });
+    },
+    selectNode(t) {
+      this.selectedUuid = t?.uuid ?? null;
+    },
+    dragNode(t) {
+      this.draggedNode = t;
+    },
+    removeNode(t) {
+      this.emancipateNode(t), t.uuid === this.selectedUuid && (this.selectedUuid = null);
+      const e = (r) => {
+        r.slots && Object.values(r.slots).forEach((n) => {
+          n.forEach((s) => {
+            this.nodeMap.delete(s.uuid), delete this.nodeRefsRecord[s.uuid], e(s);
+          });
+        });
+      };
+      e(t), this.nodeMap.delete(t.uuid), delete this.nodeRefsRecord[t.uuid], t.parentUuid || (this.rootNodes = this.rootNodes.filter(
+        (r) => r !== t.uuid
+      ));
+    },
+    emancipateNode(t) {
+      const e = t.parentUuid;
+      if (!e) return t;
+      const r = this.nodeMap.get(e);
+      return r && r.slots && Object.entries(r.slots).forEach(([n, s]) => {
+        r.slots[n] = s.filter(
+          (o) => o.uuid !== t.uuid
+        );
+      }), t.parentUuid = null, this.nodeMap.get(t.uuid) === t && this.nodeMap.delete(t.uuid), t;
+    },
+    addNodeAndChildrenToMap(t) {
+      this.nodeMap.set(t.uuid, t), t.slots && Object.values(t.slots).forEach((e) => {
+        e.forEach((r) => this.addNodeAndChildrenToMap(r));
+      });
+    },
+    appendNodeTo(t, e, r = "default") {
+      if (!this.resolver) throw new Error("Resolver is not set.");
+      if (!ie(t, e, this.resolver))
+        throw new Error(
+          `${te(
+            t
+          )} is not allowed to be a child of ${te(e)}.`
+        );
+      t = this.emancipateNode(t), t.parentUuid = e.uuid;
+      const n = this.nodeMap.get(e.uuid);
+      n && (n.slots || (n.slots = {}), n.slots[r] || (n.slots[r] = []), n.slots[r].push(t), this.nodeMap.set(n.uuid, n)), this.addNodeAndChildrenToMap(t);
+    },
+    prependNodeTo(t, e, r = "default") {
+      if (!this.resolver) throw new Error("Resolver is not set");
+      if (!ie(t, e, this.resolver))
+        throw new Error(
+          `${te(
+            t
+          )} is not allowed to be a child of ${te(e)}.`
+        );
+      t = this.emancipateNode(t), t.parentUuid = e.uuid;
+      const n = this.nodeMap.get(e.uuid);
+      n && (n.slots || (n.slots = {}), n.slots[r] || (n.slots[r] = []), n.slots[r].unshift(t), this.nodeMap.set(n.uuid, n)), this.addNodeAndChildrenToMap(t);
+    },
+    insertNodeBefore(t, e, r) {
+      if (!this.resolver) throw new Error("Resolver is not set");
+      if (!pe(t, e, this.resolver))
+        throw new Error("Can not be the sibling of the target node.");
+      t = this.emancipateNode(t);
+      const n = e.parentUuid;
+      if (!n) throw new Error("Target node has no parent.");
+      const s = this.nodeMap.get(n);
+      if (s && s.slots) {
+        const o = r || Object.keys(s.slots).find(
+          (i) => s.slots[i].some((a) => a.uuid === e.uuid)
+        );
+        if (o && s.slots[o]) {
+          const i = s.slots[o].findIndex(
+            (a) => a.uuid === e.uuid
+          );
+          i !== -1 && (s.slots[o].splice(i, 0, t), t.parentUuid = n, this.nodeMap.set(s.uuid, s), this.addNodeAndChildrenToMap(t));
+        }
+      }
+    },
+    insertNodeAfter(t, e, r) {
+      if (!this.resolver) throw new Error("Resolver is not set");
+      if (!pe(t, e, this.resolver))
+        throw new Error("Can not be the sibling of the target node.");
+      t = this.emancipateNode(t);
+      const n = e.parentUuid;
+      if (!n) throw new Error("Target node has no parent.");
+      const s = this.nodeMap.get(n);
+      if (s && s.slots) {
+        const o = r || Object.keys(s.slots).find(
+          (i) => s.slots[i].some((a) => a.uuid === e.uuid)
+        );
+        if (o && s.slots[o]) {
+          const i = s.slots[o].findIndex(
+            (a) => a.uuid === e.uuid
+          );
+          i !== -1 && (s.slots[o].splice(i + 1, 0, t), t.parentUuid = n, this.nodeMap.set(s.uuid, s), this.addNodeAndChildrenToMap(t));
+        }
+      }
+    },
+    setEventsContext(t) {
+      this.eventsContext = t;
+    }
+  },
+  getters: {
+    hasNodes: (t) => t.nodeMap.size > 0,
+    selectedNode: (t) => t.selectedUuid && t.nodeMap.get(t.selectedUuid) || null,
+    selectedRef: (t) => t.selectedUuid ? t.nodeRefsRecord[t.selectedUuid] : null,
+    getRef: (t) => (e) => t.nodeRefsRecord[e],
+    allNodes: (t) => Array.from(t.nodeMap.values()),
+    getDraggedNode: (t) => t.draggedNode,
+    nodeTree: (t) => {
+      const e = (r) => {
+        const n = t.nodeMap.get(r);
+        if (!n)
+          throw new Error(`Node with UUID ${r} not found`);
+        const s = {};
+        return n.slots && Object.entries(n.slots).forEach(([o, i]) => {
+          s[o] = i.map((a) => e(a.uuid));
+        }), {
+          ...n,
+          slots: s
+        };
+      };
+      return t.rootNodes.map((r) => e(r));
+    }
+  }
+}), bt = ["value", "onKeyup"], Et = /* @__PURE__ */ $({
+  __name: "CraftComponentSimpleText",
+  props: {
+    content: { default: "Lorem ipsum dolor sit amet..." },
+    placeholder: { default: "" },
+    componentName: { default: "div" }
+  },
+  emits: ["update:content"],
+  setup(t, { emit: e }) {
+    const r = t, n = e, s = K(!1), o = K(null), i = K(""), a = j(), { enabled: c } = Z(a), { craftNode: u } = mt(), d = w(() => c.value && !s.value), h = () => {
+      d.value && m();
+    }, m = () => {
+      i.value = r.content, s.value = !0, a.disableDragging(), ue(() => {
+        o.value && (o.value.focus(), p());
+      });
+    }, p = () => {
+      o.value && (o.value.style.height = "auto", o.value.style.height = `${o.value.scrollHeight}px`);
+    }, b = async () => {
+      if (a.enableDragging(), s.value) {
+        s.value = !1;
+        const D = o.value?.value.trim() || "";
+        if (D !== r.content) {
+          if (!u.value?.uuid)
+            return;
+          a.nodeMap.set(u.value.uuid, {
+            ...u.value,
+            props: {
+              ...u.value.props,
+              content: D
+            }
+          }), await ue(), n("update:content", D);
+        }
+      }
+    }, g = () => {
+      s.value = !1, n("update:content", i.value);
+    };
+    return le(c, (D) => {
+      !D && s.value && g();
+    }), (D, F) => (v(), N(me(t.componentName), {
+      class: oe({ "pre-wrap": !s.value, "editable-text": f(c), "is-editable": f(c), "is-editing": s.value }),
+      onDblclick: h
+    }, {
+      default: X(() => [
+        at(ne(s.value ? "" : t.content) + " ", 1),
+        s.value ? (v(), E("textarea", {
+          key: 0,
+          ref_key: "textareaRef",
+          ref: o,
+          class: "editable-text__textarea",
+          value: t.content,
+          onInput: p,
+          onBlur: b,
+          onKeyup: [
+            Pe(V(b, ["exact"]), ["enter"]),
+            Pe(g, ["esc"])
+          ]
+        }, null, 40, bt)) : x("", !0)
+      ]),
+      _: 1
+    }, 40, ["class"]));
+  }
+});
+class ye {
+  resolverMap = {};
+  constructor(e = {}) {
+    return this.setResolverMap(e), Be(this);
+  }
+  setResolverMap(e) {
+    this.resolverMap = {}, Object.entries(e).forEach(([r, n]) => {
+      this.resolverMap[n.componentName] = n;
+    });
+  }
+  resolve(e) {
+    return this.resolverMap[e];
+  }
+  getDefaultProps(e) {
+    return this.resolveNode(e)?.defaultProps || {};
+  }
+  resolveNode(e) {
+    return q(e) ? this.resolve(e.props.componentName) : this.resolve(e.componentName);
+  }
+  getSchema(e) {
+    return this.resolveNode(e)?.propsSchema || {};
+  }
+  getEventsSchema(e) {
+    return this.resolveNode(e)?.eventsSchema || {};
+  }
+  getRules(e) {
+    return this.resolveNode(e)?.rules || {};
+  }
+}
+const Ct = /* @__PURE__ */ $({
+  __name: "CraftEditor",
+  props: {
+    config: {},
+    useIframe: { type: Boolean, default: !1 },
+    iFrameStyleSheets: { default: () => [] },
+    inheritStyles: { type: Boolean, default: !1 }
+  },
+  emits: ["nodeDragStart", "nodeDragEnd", "iframeLoad"],
+  setup(t, { emit: e }) {
+    const r = t, n = e, s = j(), { getDraggedNode: o } = Z(s);
+    le(o, (a) => {
+      if (a) {
+        n("nodeDragStart", a);
+        return;
+      }
+      n("nodeDragEnd");
+    });
+    const i = K(new ye(r.config.resolverMap));
+    return re("resolver", i), (a, c) => {
+      const u = U("CraftFrame"), d = U("CraftEditorPanelLayout");
+      return v(), N(d, {
+        blueprints: t.config.blueprintsLibrary
+      }, ge({ _: 2 }, [
+        a.$slots["panel-layout"] ? {
+          name: "panel-layout",
+          fn: X(({ blueprints: h, deselectNodes: m }) => [
+            W(a.$slots, "panel-layout", {
+              blueprints: h,
+              deselectNodes: m
+            })
+          ]),
+          key: "0"
+        } : {
+          name: "default",
+          fn: X(() => [
+            G(u, {
+              useIframe: t.useIframe,
+              inheritStyles: t.inheritStyles,
+              iFrameStyleSheets: t.iFrameStyleSheets,
+              resolverMap: t.config.resolverMap,
+              onIframeLoad: c[0] || (c[0] = (h) => n("iframeLoad", h))
+            }, {
+              default: X(() => [
+                W(a.$slots, "default")
+              ]),
+              _: 3
+            }, 8, ["useIframe", "inheritStyles", "iFrameStyleSheets", "resolverMap"])
+          ]),
+          key: "1"
+        }
+      ]), 1032, ["blueprints"]);
+    };
+  }
+}), Se = He("indicator", {
+  state: () => ({
+    barSize: 2,
+    visible: !1,
+    coordinates: {
+      top: 0,
+      left: 0
+    },
+    dimensions: {
+      width: 0,
+      height: 0
+    },
+    forbidden: !1
+  }),
+  actions: {
+    hide() {
+      this.visible = !1, this.forbidden = !1;
+    },
+    show() {
+      this.visible = !0;
+    },
+    setIsForbidden(t) {
+      this.forbidden = t;
+    },
+    pointBefore(t) {
+      this.show();
+      const { top: e, left: r, height: n } = t.getBoundingClientRect();
+      this.coordinates.top = e, this.coordinates.left = r, this.dimensions.width = this.barSize, this.dimensions.height = n;
+    },
+    pointAfter(t) {
+      this.show();
+      const { top: e, left: r, width: n, height: s } = t.getBoundingClientRect();
+      this.coordinates.top = e, this.coordinates.left = r + n, this.dimensions.width = this.barSize, this.dimensions.height = s;
+    },
+    pointInside(t) {
+      this.show();
+      const e = De(t), { top: r, left: n, width: s, height: o } = t.getBoundingClientRect(), i = Number.parseInt(e.paddingLeft), a = Number.parseInt(e.paddingTop), c = Number.parseInt(e.paddingRight);
+      this.coordinates.top = r + o - a, this.coordinates.left = n + i, this.dimensions.width = s - i - c, this.dimensions.height = this.barSize;
+    },
+    pointInsideTop(t) {
+      this.show();
+      const e = De(t), { top: r, left: n, width: s } = t.getBoundingClientRect(), o = Number.parseInt(e.paddingLeft), i = Number.parseInt(e.paddingTop), a = Number.parseInt(e.paddingRight);
+      this.coordinates.top = r + i, this.coordinates.left = n + o, this.dimensions.width = s - o - a, this.dimensions.height = this.barSize;
+    }
+  },
+  getters: {
+    isShown: (t) => t.visible,
+    isForbidden: (t) => t.forbidden,
+    position: (t) => t.coordinates,
+    size: (t) => t.dimensions
+  }
+});
+function De(t) {
+  const { paddingTop: e, paddingLeft: r, paddingRight: n, paddingBottom: s } = getComputedStyle(t), o = {
+    paddingTop: e,
+    paddingLeft: r,
+    paddingRight: n,
+    paddingBottom: s
+  };
+  return Object.keys(o).forEach((i) => {
+    o[i] = parseInt(o[i].slice(0, -2), 10);
+  }), o;
+}
+const wt = /* @__PURE__ */ $({
+  name: "CraftEditorBlueprint",
+  __name: "CraftEditorBlueprint",
+  props: {
+    craftNode: {}
+  },
+  setup(t) {
+    const e = j(), r = Se(), n = t, s = (i) => {
+      console.log("CraftEditorBlueprint - dragging node:", n.craftNode), console.log("CraftEditorBlueprint - node.componentName:", n.craftNode.componentName), console.log("CraftEditorBlueprint - node.props:", n.craftNode.props), e.dragNode(n.craftNode);
+    }, o = (i) => {
+      i.stopPropagation(), e.dragNode(null), r.hide();
+    };
+    return (i, a) => (v(), E("div", {
+      draggable: !0,
+      onDragstart: V(s, ["stop"]),
+      onDragend: o
+    }, [
+      W(i.$slots, "default")
+    ], 32));
+  }
+}), Ye = (t, e) => Object.keys(t.blueprints).map((r) => {
+  const n = t.blueprints[r], s = e.getDefaultProps({
+    ...n,
+    uuid: de()
+  });
+  return {
+    ...n,
+    props: { ...s, ...n.props }
+  };
+}), _t = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  blueprintsWithDefaults: Ye
+}, Symbol.toStringTag, { value: "Module" })), Ot = { key: 0 }, Nt = { class: "flex flex-wrap gap-2 p-1" }, xt = { class: "v-craft-blueprint" }, St = { class: "v-craft-blueprint-label" }, At = /* @__PURE__ */ $({
+  __name: "CraftEditorBlueprintsList",
+  props: {
+    blueprints: {}
+  },
+  setup(t) {
+    const e = ae("resolver");
+    return (r, n) => {
+      const s = U("CraftEditorBlueprint");
+      return f(e) ? (v(), E("div", Ot, [
+        (v(!0), E(T, null, M(t.blueprints.groups, (o) => (v(), E("div", null, [
+          W(r.$slots, "blueprint-group", {
+            group: o,
+            resolver: f(e)
+          }, () => [
+            O("h4", null, ne(o.label), 1),
+            O("div", Nt, [
+              (v(!0), E(T, null, M(f(Ye)(o, f(e)), (i, a) => (v(), N(s, {
+                craftNode: i,
+                key: a
+              }, {
+                default: X(() => [
+                  O("div", xt, [
+                    O("div", St, ne(i.label), 1)
+                  ])
+                ]),
+                _: 2
+              }, 1032, ["craftNode"]))), 128))
+            ])
+          ])
+        ]))), 256))
+      ])) : x("", !0);
+    };
+  }
+}), Pt = { class: "v-craft-panel v-craft-blueprints-panel" }, Dt = { class: "v-craft-panel-content" }, kt = /* @__PURE__ */ $({
+  name: "CraftEditorPanelBlueprints",
+  __name: "CraftEditorPanelBlueprints",
+  props: {
+    blueprints: {}
+  },
+  emits: ["close"],
+  setup(t) {
+    return (e, r) => {
+      const n = U("CraftEditorBlueprintsList");
+      return v(), E("div", Pt, [
+        r[0] || (r[0] = O("h3", { class: "v-craft-title" }, "blueprints", -1)),
+        O("div", Dt, [
+          G(n, { blueprints: t.blueprints }, null, 8, ["blueprints"])
+        ])
+      ]);
+    };
+  }
+}), be = (t, e) => {
+  const r = t.__vccOpts || t;
+  for (const [n, s] of e)
+    r[n] = s;
+  return r;
+}, $t = /* @__PURE__ */ be(kt, [["__scopeId", "data-v-a6de4dca"]]), Rt = /* @__PURE__ */ $({
+  __name: "CraftEditorPanelForm",
+  props: {
+    craftNode: {},
+    model: {},
+    schema: { default: () => ({}) }
+  },
+  emits: ["update"],
+  setup(t, { emit: e }) {
+    const r = t, n = e, s = ce(r, "model"), o = ce(r, "schema"), i = ce(r, "craftNode"), a = w(
+      () => s.value ? { ...s.value } : {}
+    ), c = Ve((d) => {
+      n("update", d);
+    }, 50), u = (d) => {
+      d != null && c(d);
+    };
+    return Le(() => c.cancel()), (d, h) => W(d.$slots, "panel-content", {
+      craftNode: i.value,
+      model: a.value,
+      handleFormInput: u,
+      schema: o.value
+    });
+  }
+}), It = { class: "v-craft-panel v-craft-layers-panel" }, Mt = { class: "v-craft-layers" }, Tt = { class: "v-craft-node-layers" }, Ut = /* @__PURE__ */ $({
+  name: "CraftEditorPanelLayers",
+  __name: "CraftEditorPanelLayers",
+  setup(t) {
+    const e = j(), { nodeTree: r } = Z(e), n = (s) => {
+      e.selectNode(s);
+    };
+    return (s, o) => {
+      const i = U("CraftEditorPanelNodeLayer");
+      return v(), E("div", It, [
+        o[0] || (o[0] = O("h3", { class: "v-craft-title" }, "tree", -1)),
+        O("div", Mt, [
+          O("ul", Tt, [
+            (v(!0), E(T, null, M(f(r), (a, c) => (v(), N(i, {
+              key: c,
+              craftNode: a,
+              onLayerClick: n
+            }, null, 8, ["craftNode"]))), 128))
+          ])
+        ])
+      ]);
+    };
+  }
+}), Bt = /* @__PURE__ */ be(Ut, [["__scopeId", "data-v-e2502bab"]]), Lt = { key: 0 }, jt = {
+  key: 1,
+  class: "v-craft-panel-manager"
+}, Ft = { class: "flex w-full justify-between gap-10" }, Ht = { class: "v-craft-grid-panel v-craft-panel-left shrink" }, Vt = { class: "v-craft-grid-panel v-craft-panel-right shrink" }, Kt = /* @__PURE__ */ $({
+  __name: "CraftEditorPanelLayout",
+  props: {
+    blueprints: {}
+  },
+  setup(t) {
+    const e = j(), r = () => {
+      e.selectNode(null);
+    };
+    return (n, s) => {
+      const o = U("CraftEditorPanelBlueprints"), i = U("CraftEditorPanelLayers"), a = U("CraftEditorPanelSettings");
+      return n.$slots["panel-layout"] ? (v(), E("div", Lt, [
+        W(n.$slots, "panel-layout", {
+          blueprints: t.blueprints,
+          deselectNodes: r
+        }, void 0, !0)
+      ])) : (v(), E("div", jt, [
+        O("div", Ft, [
+          O("div", Ht, [
+            G(o, { blueprints: t.blueprints }, null, 8, ["blueprints"])
+          ]),
+          O("div", {
+            class: "v-craft-panel-center flex grow",
+            onClick: V(r, ["stop"])
+          }, [
+            W(n.$slots, "default", {}, void 0, !0)
+          ]),
+          O("div", Vt, [
+            G(i),
+            G(a)
+          ])
+        ])
+      ]));
+    };
+  }
+}), Xt = /* @__PURE__ */ be(Kt, [["__scopeId", "data-v-d60526f7"]]), zt = {
+  key: 0,
+  class: "v-craft-panel-settings formkit-fieldset v-craft-scrollable-content"
+}, qt = /* @__PURE__ */ $({
+  __name: "CraftEditorPanelNodeEventsSettings",
+  props: {
+    craftNode: {},
+    schema: { default: () => ({}) }
+  },
+  emits: ["update:events"],
+  setup(t, { emit: e }) {
+    const r = t, { craftNode: n, schema: s } = fe(r), o = e;
+    return (i, a) => {
+      const c = U("CraftEditorPanelForm");
+      return v(), N(c, {
+        craftNode: f(n),
+        schema: f(s),
+        model: f(n)?.events,
+        onUpdate: a[0] || (a[0] = (u) => o("update:events", u))
+      }, {
+        "panel-content": X(({ craftNode: u, model: d, handleFormInput: h, schema: m }) => [
+          m ? (v(), E("fieldset", zt, [
+            a[1] || (a[1] = O("legend", { class: "formkit-legend" }, "Events", -1)),
+            (v(), N(f(Ke), {
+              key: u?.uuid,
+              type: "form",
+              value: d,
+              onInput: h,
+              actions: !1
+            }, {
+              default: X(() => [
+                G(f(Xe), {
+                  schema: m
+                }, null, 8, ["schema"])
+              ]),
+              _: 2
+            }, 1032, ["value", "onInput"]))
+          ])) : x("", !0)
+        ]),
+        _: 1
+      }, 8, ["craftNode", "schema", "model"]);
+    };
+  }
+}), Wt = { class: "v-craft-component-layer-face" }, Yt = { class: "v-craft-component-name" }, Qt = {
+  key: 0,
+  class: "v-craft-node-layers nested-layers"
+}, Gt = /* @__PURE__ */ $({
+  __name: "CraftEditorPanelNodeLayer",
+  props: {
+    craftNode: {},
+    visible: { type: Boolean, default: !0 }
+  },
+  emits: ["layer-click"],
+  setup(t, { emit: e }) {
+    const r = t, { craftNode: n, visible: s } = fe(r), o = w(
+      () => s.value && n.value.visible === void 0 || n.value.visible
+    ), i = e, a = j(), { selectedNode: c } = Z(a), u = w(() => te(n.value)), d = w(
+      () => c?.value?.uuid === n.value.uuid
+    ), h = () => {
+      a.toggleNodeVisibility(n.value);
+    };
+    return (m, p) => {
+      const b = U("CraftEditorPanelNodeLayer", !0);
+      return v(), E("li", {
+        class: oe(["v-craft-node-layer", {
+          "v-craft-node-layer-selected": d.value
+        }]),
+        onClick: p[1] || (p[1] = V((g) => i("layer-click", f(n)), ["prevent", "stop"]))
+      }, [
+        O("div", Wt, [
+          O("div", Yt, ne(u.value), 1),
+          O("button", {
+            type: "button",
+            class: "v-craft-component-icon",
+            onClick: V(h, ["prevent", "stop"])
+          }, ne(o.value ? "hide" : "show"), 1)
+        ]),
+        f(n).slots && Object.keys(f(n).slots).length > 0 ? (v(), E("ul", Qt, [
+          (v(!0), E(T, null, M(f(n).slots, (g, D) => (v(), E(T, { key: D }, [
+            (v(!0), E(T, null, M(g, (F, A) => (v(), N(b, {
+              key: `${D}-${A}`,
+              craftNode: F,
+              onLayerClick: p[0] || (p[0] = (z) => i("layer-click", z)),
+              visible: o.value
+            }, null, 8, ["craftNode", "visible"]))), 128))
+          ], 64))), 128))
+        ])) : x("", !0)
+      ], 2);
+    };
+  }
+}), Zt = /* @__PURE__ */ be(Gt, [["__scopeId", "data-v-0b94201d"]]), Jt = {
+  key: 0,
+  class: "v-craft-panel-settings formkit-fieldset v-craft-scrollable-content"
+}, er = /* @__PURE__ */ $({
+  __name: "CraftEditorPanelNodeSettings",
+  props: {
+    craftNode: {},
+    schema: { default: () => ({}) }
+  },
+  emits: ["update:props"],
+  setup(t, { emit: e }) {
+    const r = t, { craftNode: n, schema: s } = fe(r), o = e;
+    return (i, a) => {
+      const c = U("CraftEditorPanelForm");
+      return v(), N(c, {
+        craftNode: f(n),
+        schema: f(s),
+        model: f(n)?.props,
+        onUpdate: a[0] || (a[0] = (u) => o("update:props", u))
+      }, {
+        "panel-content": X(({ craftNode: u, model: d, handleFormInput: h, schema: m }) => [
+          m ? (v(), E("fieldset", Jt, [
+            a[1] || (a[1] = O("legend", { class: "formkit-legend" }, "Properties", -1)),
+            (v(), N(f(Ke), {
+              key: u?.uuid,
+              type: "form",
+              value: d,
+              onInput: h,
+              actions: !1
+            }, {
+              default: X(() => [
+                G(f(Xe), {
+                  schema: m
+                }, null, 8, ["schema"])
+              ]),
+              _: 2
+            }, 1032, ["value", "onInput"]))
+          ])) : x("", !0)
+        ]),
+        _: 1
+      }, 8, ["craftNode", "schema", "model"]);
+    };
+  }
+}), tr = { class: "text-sm" }, rr = { key: 0 }, nr = {
+  key: 0,
+  class: "v-craft-settings"
+}, sr = {
+  key: 1,
+  class: "v-craft-settings"
+}, or = {
+  class: "v-craft-actions",
+  "data-type": "button"
+}, ir = /* @__PURE__ */ $({
+  __name: "CraftEditorPanelSettings",
+  setup(t) {
+    const e = j(), { selectedNode: r } = Z(e), n = ae("resolver"), s = w(() => !r.value || !n?.value ? [] : n.value.getSchema(r.value)), o = w(() => !r.value || !n?.value ? [] : n.value.getEventsSchema(r.value)), i = w(
+      () => r.value && r.value.parentUuid
+    ), a = () => {
+      r.value && e.removeNode(r.value);
+    }, c = w(
+      () => r.value ? `${n?.value?.resolveNode(r.value)?.componentName || "Unknown"}` : ""
+    ), u = (h) => {
+      r.value && h && e.updateNodeProps(r.value.uuid, h);
+    }, d = (h) => {
+      r.value && h && e.updateNodeEvents(r.value.uuid, h);
+    };
+    return (h, m) => {
+      const p = U("CraftEditorPanelNodeSettings"), b = U("CraftEditorPanelNodeEventsSettings");
+      return W(h.$slots, "panel-content", {
+        selectedNode: f(r),
+        nodeName: c.value,
+        handlePropsUpdate: u,
+        schema: s.value,
+        eventsSchema: o.value,
+        handleEventsUpdate: d,
+        deleteable: i.value,
+        removeNode: a
+      }, () => [
+        O("div", {
+          ref: "panel",
+          class: "v-craft-panel v-craft-settings-panel",
+          onClick: V(() => !1, ["prevent", "stop"])
+        }, [
+          m[1] || (m[1] = O("h3", { class: "v-craft-title" }, "component inspector", -1)),
+          O("span", tr, ne(f(r)?.uuid), 1),
+          f(r) ? x("", !0) : (v(), E("div", rr, [...m[0] || (m[0] = [
+            O("p", null, "select a component to inspect", -1)
+          ])])),
+          O("div", {
+            class: oe(["v-craft-properties", { "v-craft-visible": f(r) }])
+          }, [
+            O("h4", null, ne(c.value), 1),
+            s.value ? (v(), E("div", nr, [
+              G(p, {
+                craftNode: f(r),
+                schema: s.value,
+                "onUpdate:props": u
+              }, null, 8, ["craftNode", "schema"])
+            ])) : x("", !0),
+            o.value && f(r) ? (v(), E("div", sr, [
+              G(b, {
+                craftNode: f(r),
+                schema: o.value,
+                "onUpdate:events": d
+              }, null, 8, ["craftNode", "schema"])
+            ])) : x("", !0),
+            O("div", or, [
+              i.value ? (v(), E("button", {
+                key: 0,
+                class: "formkit-input v-craft-delete",
+                onClick: V(a, ["prevent"])
+              }, " Delete ")) : x("", !0)
+            ])
+          ], 2)
+        ], 512)
+      ]);
+    };
+  }
+}), ke = /* @__PURE__ */ $({
+  __name: "CraftDropIndicator",
+  setup(t) {
+    const e = Se(), r = () => {
+      const { top: n, left: s } = e.position, { width: o, height: i } = e.size;
+      return {
+        top: `${n}px`,
+        left: `${s}px`,
+        height: `${i}px`,
+        width: `${o}px`
+      };
+    };
+    return (n, s) => f(e).isShown ? (v(), E("div", {
+      key: 0,
+      class: oe(["v-craft-indicator", { "v-craft-forbidden": f(e).isForbidden }]),
+      style: je(r())
+    }, null, 6)) : x("", !0);
+  }
+}), Qe = /* @__PURE__ */ $({
+  __name: "CraftIframe",
+  props: {
+    iframeClass: { default: "" },
+    iframeStyle: { type: [Boolean, null, String, Object, Array], default: () => ({}) },
+    inheritStyles: { type: Boolean, default: !1 },
+    styleSheets: { default: () => [] },
+    styles: { default: () => [] },
+    iframeId: { default: "v-craft-iframe" },
+    width: { default: "auto" },
+    height: { default: "auto" }
+  },
+  emits: ["iframeLoad"],
+  setup(t, { emit: e }) {
+    const r = t, n = K(), s = K(!1), o = K(), i = K(), a = K(), { height: c, width: u } = fe(r), d = w(() => c.value === "auto");
+    let h = 0, m = !1;
+    const p = () => {
+      ue(() => {
+        if (!n.value) {
+          console.error("iframe could not be loaded.");
+          return;
+        }
+        R("iframeLoad", n.value), n.value?.setAttribute("data-iframe-ready", "true"), z(), r.inheritStyles && D(), r.styles.forEach((y) => {
+          n.value && F(n.value, y);
+        }), r.styleSheets.forEach((y) => {
+          n.value && A(n.value, y);
+        }), s.value = !0, ue(() => {
+          n.value && (o.value = n.value?.contentWindow?.document.body, b());
+        });
+      });
+    };
+    le([u, c], ([y, k]) => {
+      b();
+    });
+    const b = () => {
+      if (!n.value)
+        return;
+      const y = n.value.contentWindow;
+      if (!y) return;
+      if (i.value?.disconnect(), a.value?.disconnect(), c.value !== "auto" || u.value !== "auto") {
+        n.value.style.height = `${c.value}px`, n.value.style.width = `${u.value}px`;
+        return;
+      }
+      n.value.style.width = "100%", n.value.style.height = "100%", i.value = new MutationObserver(() => {
+        setTimeout(g, 100);
+      }), i.value.observe(y.document.body, {
+        childList: !0,
+        subtree: !0,
+        attributes: !0,
+        characterData: !0
+      });
+      const k = new ResizeObserver(() => {
+        g(), k.disconnect();
+      });
+      k.observe(y.document.documentElement), g();
+    }, g = () => {
+      m || (m = !0, ue(() => {
+        const y = n.value?.contentWindow?.document;
+        if (!y) {
+          m = !1;
+          return;
+        }
+        const k = n.value?.parentElement;
+        let I = 0;
+        if (k) {
+          const B = k.clientHeight, Q = n.value?.offsetTop || 0;
+          I = B - Q;
+        }
+        const J = y.body, he = y.documentElement, P = Math.max(
+          150,
+          J.scrollHeight,
+          J.offsetHeight,
+          he.scrollHeight,
+          he.offsetHeight
+        ), S = Math.max(P, I);
+        n.value && Math.abs(S - h) > 1 && (h = S, n.value.style.height = `${S}px`), m = !1;
+      }));
+    }, D = () => {
+      const y = n.value?.contentWindow?.parent.document;
+      if (!y) return;
+      Array.from(y.querySelectorAll("style") ?? []).forEach((J) => {
+        n.value?.contentDocument?.head.appendChild(J.cloneNode(!0));
+      }), Array.from(y.querySelectorAll("link[rel='stylesheet']") ?? []).forEach((J) => {
+        n.value?.contentDocument?.head.appendChild(J.cloneNode(!0));
+      });
+    }, F = (y, k) => {
+      const I = document.createElement("style");
+      I.innerHTML = k, y?.contentWindow?.document.getElementsByTagName("head").item(0)?.appendChild(I);
+    }, A = (y, k) => {
+      const I = document.createElement("link");
+      I.rel = "stylesheet", I.href = k, y.contentWindow?.document.head.appendChild(I);
+    }, z = () => {
+      const y = n.value?.contentWindow?.document;
+      if (!y) return;
+      const k = y.querySelector("body");
+      if (!k) return;
+      const I = y.createAttribute("id");
+      I.nodeValue = "v-craft-body", k.attributes.setNamedItem(I);
+    }, R = e;
+    return Le(() => {
+      i.value?.disconnect(), a.value?.disconnect();
+    }), (y, k) => lt((v(), E("div", {
+      class: oe({ "h-full": d.value })
+    }, [
+      O("iframe", {
+        id: "v-craft-iframe",
+        ref_key: "iframeRef",
+        ref: n,
+        class: oe(t.iframeClass),
+        style: je(t.iframeStyle),
+        onload: p
+      }, null, 6),
+      s.value ? (v(), N(ut, {
+        key: 0,
+        to: n.value?.contentWindow?.document.body
+      }, [
+        W(y.$slots, "default")
+      ], 8, ["to"])) : x("", !0)
+    ], 2)), [
+      [ct, y.$slots.default]
+    ]);
+  }
+}), ar = (t) => typeof t.type == "symbol" ? "Fragment" : typeof t.type == "string" ? t.type : t.type.name ? t.type.name : "anonmymous", Ce = (t, e, r = null) => {
+  const n = ar(e), { props: s } = e, o = {
+    componentName: n,
+    props: s,
+    slots: {},
+    parentUuid: r?.uuid ?? null,
+    uuid: de()
+  };
+  return e.children && (typeof e.children == "object" && !Array.isArray(e.children) ? Object.entries(e.children).forEach(([i, a]) => {
+    if (typeof a == "function") {
+      const c = a();
+      c && (o.slots[i] = $e(t, c, o));
+    }
+  }) : Array.isArray(e.children) && (o.slots.default = $e(t, e.children, o))), o;
+}, $e = (t, e, r) => !e || !(e instanceof Array) ? [] : e.map((n) => Ce(t, n, r)).filter((n) => !!n), lr = (t) => {
+  const e = j(), { hasNodes: r } = Z(e), n = t ? K(new ye(t)) : ae("resolver");
+  n?.value && e.setResolver(n.value), t && re("resolver", n);
+  const s = () => {
+    if (n?.value && !r.value) {
+      const o = Ue(), a = (o.default ? o.default() : []).flatMap((c) => {
+        if (c.key === "_default" && c.children && Array.isArray(c.children))
+          return c.children.map((u) => {
+            const d = Ce(n.value, u);
+            return d || console.error("Invalid node created from child:", u), d;
+          }).filter(Boolean);
+        {
+          const u = Ce(n.value, c);
+          return u || console.error("Invalid node created from slot:", c), [u];
+        }
+      }).filter(Boolean);
+      a.length && e.setNodes(a);
+    }
+  };
+  return Ne(s), le(
+    () => n?.value,
+    (o) => {
+      o && e.setResolver(o);
+    }
+  ), {
+    editor: e,
+    mountNodes: s
+  };
+}, ur = { class: "v-craft-frame" }, cr = /* @__PURE__ */ $({
+  name: "CraftFrame",
+  __name: "CraftFrame",
+  props: {
+    iFrameHeight: { default: "auto" },
+    iFrameStyle: { type: [Boolean, null, String, Object, Array], default: () => ({}) },
+    iFrameStyleSheets: { default: () => [] },
+    iFrameStyles: { default: () => [] },
+    iFrameWidth: { default: "auto" },
+    inheritStyles: { type: Boolean, default: !1 },
+    resolverMap: {},
+    useIframe: { type: Boolean, default: !1 },
+    viewOnly: { type: Boolean, default: !1 }
+  },
+  emits: ["iframeLoad"],
+  setup(t, { emit: e }) {
+    const r = t, { iFrameWidth: n, iFrameHeight: s } = fe(r), o = (h) => {
+      i("iframeLoad", h);
+    }, i = e, { editor: a } = lr(r.resolverMap), { nodeTree: c, hasNodes: u, enabled: d } = Z(a);
+    return (h, m) => {
+      const p = U("CraftNodeViewer"), b = U("CraftNodeEditor");
+      return v(), E("div", ur, [
+        t.useIframe ? (v(), N(Qe, {
+          key: 0,
+          onIframeLoad: o,
+          inheritStyles: t.inheritStyles,
+          styles: [
+            ...t.iFrameStyles
+          ],
+          "iframe-style": t.iFrameStyle,
+          "style-sheets": t.iFrameStyleSheets,
+          width: f(n),
+          height: f(s)
+        }, {
+          default: X(() => [
+            (t.viewOnly || !f(d)) && f(u) ? (v(!0), E(T, { key: 0 }, M(f(c), (g) => (v(), N(p, {
+              key: `${g.uuid}-view`,
+              craftNode: g
+            }, null, 8, ["craftNode"]))), 128)) : x("", !0),
+            !t.viewOnly && f(d) && f(u) ? (v(!0), E(T, { key: 1 }, M(f(c), (g) => (v(), N(b, {
+              key: `${g.uuid}-edit`,
+              craftNode: g
+            }, null, 8, ["craftNode"]))), 128)) : x("", !0),
+            !t.viewOnly && f(d) ? (v(), N(ke, { key: 2 })) : x("", !0)
+          ]),
+          _: 1
+        }, 8, ["inheritStyles", "styles", "iframe-style", "style-sheets", "width", "height"])) : x("", !0),
+        !t.useIframe && (t.viewOnly || !f(d)) && f(u) ? (v(!0), E(T, { key: 1 }, M(f(c), (g) => (v(), N(p, {
+          key: `${g.uuid}-view`,
+          craftNode: g
+        }, null, 8, ["craftNode"]))), 128)) : x("", !0),
+        !t.useIframe && !t.viewOnly && f(d) && f(u) ? (v(!0), E(T, { key: 2 }, M(f(c), (g) => (v(), N(b, {
+          key: `${g.uuid}-edit`,
+          craftNode: g
+        }, null, 8, ["craftNode"]))), 128)) : x("", !0),
+        !t.useIframe && !t.viewOnly && f(d) ? (v(), N(ke, { key: 3 })) : x("", !0)
+      ]);
+    };
+  }
+}), dr = (t, e) => {
+  const r = j(), { enabled: n, selectedUuid: s, draggingDisabled: o } = Z(r);
+  let i = null;
+  const a = () => {
+    const h = e?.value?.$el;
+    h && h !== i && (i = h, r.setNodeRef(t, h));
+  };
+  Ne(a), le(e, a, { flush: "post" });
+  const c = w(
+    () => s.value === t.uuid
+  );
+  return {
+    isDraggable: w(() => n.value && !o.value && yt(t)),
+    isSelected: c,
+    selectNode: () => {
+      n.value && r.selectNode(t);
+    }
+  };
+}, Ge = (t, e, r) => {
+  const n = /* @__PURE__ */ new Map(), s = () => {
+    !t.value?.events || !Object.values(t.value.events).length || Object.entries(t.value.events).forEach(([o, i]) => {
+      if (!i.trim())
+        return;
+      const a = (...c) => {
+        try {
+          new Function(
+            "ctx",
+            "craftNode",
+            "args",
+            i
+          )(
+            { ...r, editor: e },
+            e.nodeMap.get(t.value.uuid),
+            ...c
+          );
+        } catch (u) {
+          console.error(
+            `Event code execution failed with code: 
+${i}
+
+Error:`,
+            u
+          );
+        }
+      };
+      n.set(o, a);
+    });
+  };
+  return le(
+    () => t,
+    () => {
+      s();
+    }
+  ), dt(() => {
+    s();
+  }), ft(() => {
+    n.clear();
+  }), {
+    eventHandlers: w(() => Object.fromEntries(n))
+  };
+}, Ze = (t) => {
+  const e = (() => {
+    try {
+      return j();
+    } catch {
+      return null;
+    }
+  })(), r = w(() => e ? Z(e).enabled?.value ?? !1 : !1), n = w(() => t.value?.visible !== !1);
+  return re("craftNode", ht(t)), {
+    editor: e,
+    craftNode: t,
+    enabled: r,
+    visible: n
+  };
+}, Je = (t, e) => {
+  const r = e.getBoundingClientRect();
+  return t.clientX - r.left < r.width / 2;
+}, et = (t, e) => {
+  const r = e.getBoundingClientRect();
+  return t.clientY - r.top < r.height / 2;
+}, tt = (t, e) => {
+  const r = e.getBoundingClientRect();
+  return t.clientX - r.left < 15 || t.clientY - r.top < 15 || r.right - t.clientX < 15 || r.bottom - t.clientY < 15;
+}, rt = (t, e, { editor: r, indicator: n, craftNode: s, resolver: o }) => {
+  if (r.draggedNode) {
+    if (n.setIsForbidden(!pe(r.draggedNode, s.value, o)), Je(t, e)) {
+      n.pointBefore(e);
+      return;
+    }
+    n.pointAfter(e);
+  }
+}, fr = (t, e, { editor: r, indicator: n, craftNode: s, resolver: o }) => {
+  if (!r.draggedNode) return;
+  const a = t.target.closest(".v-craft-drop-text");
+  if (a) {
+    const u = !ie(r.draggedNode, s.value, o);
+    n.setIsForbidden(u), n.pointInside(a);
+    return;
+  }
+  if (tt(t, e)) {
+    rt(t, e, { editor: r, indicator: n, craftNode: s, resolver: o });
+    return;
+  }
+  const c = !ie(r.draggedNode, s.value, o);
+  if (n.setIsForbidden(c), et(t, e)) {
+    n.pointInsideTop(e);
+    return;
+  }
+  n.pointInside(e);
+}, hr = (t, e, r) => {
+  if (q(r.craftNode.value)) {
+    fr(t, e, r);
+    return;
+  }
+  rt(t, e, r);
+}, nt = (t, e, r, n) => {
+  if (!pe(
+    r,
+    n.craftNode.value,
+    n.resolver
+  ))
+    return n.craftNode.value;
+  const s = n.craftNode.value.parentUuid ? n.editor.nodeMap.get(n.craftNode.value.parentUuid) : null;
+  if (!s)
+    return n.craftNode.value;
+  const o = Object.values(s.slots || {}).flat().find(
+    (i) => i.uuid === n.craftNode.value.uuid
+  );
+  return !o || o.uuid === r.uuid || (Je(t, e) ? n.editor.insertNodeBefore(r, o) : n.editor.insertNodeAfter(r, o)), n.craftNode.value;
+}, pr = (t, e) => {
+  if (!t.slots || Object.keys(t.slots).length === 0) {
+    const n = e.resolveNode?.(t)?.slots;
+    n && n.length > 0 ? (t.slots = {}, n.forEach((s) => {
+      t.slots[s] = [];
+    })) : t.slots = { default: [] };
+  }
+  return t;
+}, st = (t, e, r, n) => {
+  const { editor: s, resolver: o, craftNode: i } = n, a = t.target, c = s.nodeMap.get(a.id);
+  if (c && q(c))
+    return st(t, e, r, { ...n, craftNode: K(c) }), n.craftNode.value;
+  const u = a.closest(".v-craft-drop-text");
+  let d = "default";
+  if (u) {
+    const h = u.getAttribute("data-slot-name");
+    h && (d = h);
+  } else {
+    if (tt(t, e))
+      return nt(t, e, r, n);
+    const h = n.craftNode.value.slots || {}, m = Object.keys(h);
+    d = m.length > 0 ? m[0] : "default";
+  }
+  return ie(
+    r,
+    n.craftNode.value,
+    n.resolver
+  ) && (et(t, e) ? n.editor.prependNodeTo(r, n.craftNode.value, d) : n.editor.appendNodeTo(r, n.craftNode.value, d)), n.craftNode.value;
+}, vr = (t, e, r) => {
+  if (!r.editor.draggedNode)
+    return r.craftNode.value;
+  const n = (() => {
+    let s;
+    return r.editor.draggedNode?.uuid ? s = JSON.parse(JSON.stringify(r.editor.draggedNode)) : s = We(
+      JSON.parse(JSON.stringify(r.editor.draggedNode))
+    ), pr(s, r.resolver);
+  })();
+  return q(r.craftNode.value) ? st(t, e, n, r) : nt(t, e, n, r);
+}, Re = {
+  handleDragOver: hr,
+  handleDrop: vr
+}, mr = (t, e, r) => {
+  const n = j(), s = Se(), o = (u) => {
+    n.enabled && n.dragNode(t.value);
+  }, i = Ve((u) => {
+    n.enabled && e.value?.$el && Re.handleDragOver(u, e.value.$el, {
+      editor: n,
+      indicator: s,
+      craftNode: t,
+      resolver: r
+    });
+  }, 8);
+  return {
+    handleDragStart: o,
+    handleDragOver: i,
+    handleDrop: (u) => {
+      n.enabled && e.value?.$el && Re.handleDrop(u, e.value.$el, {
+        editor: n,
+        indicator: s,
+        craftNode: t,
+        resolver: r
+      });
+    },
+    handleDragEnd: () => {
+      n.enabled && (n.dragNode(null), s.hide());
+    }
+  };
+}, gr = ["data-slot-name"], yr = { class: "v-craft-slot-name" }, br = /* @__PURE__ */ $({
+  name: "CraftNodeEditor",
+  __name: "CraftNodeEditor",
+  props: {
+    craftNode: {}
+  },
+  setup(t) {
+    const r = ce(t, "craftNode"), { editor: n, visible: s } = Ze(r), { resolvedNode: o, defaultProps: i, resolver: a } = xe(r);
+    a.value && re("resolver", a);
+    const c = K(null), u = w(() => n?.nodeDataMap[r.value.uuid]), { isSelected: d, isDraggable: h, selectNode: m } = dr(
+      r.value,
+      c
+    ), { handleDragStart: p, handleDragOver: b, handleDrop: g, handleDragEnd: D } = mr(r, c, a.value), { eventHandlers: F } = Ge(
+      r,
+      n,
+      n?.eventsContext || {}
+    ), A = w(() => a?.value?.resolve(r.value.componentName)?.componentName || r.value.componentName), z = () => {
+      m();
+    }, R = (P) => {
+      let S = 0;
+      for (let L = 0; L < P.length; L++)
+        S = P.charCodeAt(L) + ((S << 5) - S);
+      const B = S % 360, Q = 70 + S % 30, H = 45 + S % 30;
+      return `hsla(${B}, ${Q}%, ${H}%, 0.9)`;
+    }, y = w(() => R(r.value.uuid)), k = w(() => {
+      const P = [], B = a?.value?.resolveNode?.(r.value)?.slots;
+      return B && B.length > 0 ? P.push(...B) : P.push("default"), P;
+    }), I = w(() => q(r.value) ? !0 : Object.values(r.value.slots || {}).some((P) => P.length > 0)), J = (P, S) => u.value ? u.value.slotName && u.value.slotName !== S ? [] : he(u.value, P) : [], he = (P, S) => P.type === "single" ? S.map((B) => ({
+      key: `${B.uuid}-single`,
+      craftNode: {
+        ...B,
+        props: {
+          ...B.props,
+          ...P.item || {}
+        }
+      }
+    })) : P.type === "list" ? P.list ? S.reduce((B, Q) => B.concat(
+      P.list.map((H, L) => ({
+        key: `${Q.uuid}-data-${L}`,
+        craftNode: {
+          ...Q,
+          props: {
+            ...Q.props,
+            ...H || {}
+          }
+        }
+      }))
+    ), []) : [] : [];
+    return (P, S) => {
+      const B = U("CraftNodeViewer"), Q = U("CraftNodeEditor", !0);
+      return f(s) && r.value && f(o) ? (v(), N(me(f(o).componentName), Oe({
+        key: 0,
+        ref_key: "nodeRef",
+        ref: c
+      }, { ...f(i), ...r.value.props }, Fe(f(F)), {
+        "data-node-name": A.value,
+        style: { "--node-color": y.value },
+        class: {
+          "v-craft-node-selected": f(d),
+          "v-craft-node": f(n)?.enabled,
+          "v-craft-canvas": f(q)(r.value),
+          "v-craft-empty": !r.value.slots || Object.keys(r.value.slots).length === 0 || Object.values(r.value.slots).every((H) => H.length === 0),
+          "v-craft-other-node-dragged": f(n)?.draggedNode && !f(qe)(f(n).draggedNode, r.value)
+        },
+        draggable: f(n)?.enabled && f(h),
+        onClick: V(z, ["prevent", "stop"]),
+        onDragend: V(f(D), ["prevent", "stop"]),
+        onDragover: V(f(b), ["prevent", "stop"]),
+        onDragstart: V(f(p), ["stop"]),
+        onDrop: V(f(g), ["prevent", "stop"])
+      }), ge({ _: 2 }, [
+        M(k.value, (H) => ({
+          name: H,
+          fn: X(() => [
+            f(q)(r.value) && r.value.slots[H]?.length == 0 ? (v(), E("div", {
+              key: 0,
+              class: "v-craft-drop-text",
+              "data-slot-name": H,
+              onDragover: S[0] || (S[0] = V(
+                //@ts-ignore
+                (...L) => f(b) && f(b)(...L),
+                ["prevent", "stop"]
+              )),
+              onDrop: S[1] || (S[1] = V(
+                //@ts-ignore
+                (...L) => f(g) && f(g)(...L),
+                ["prevent", "stop"]
+              ))
+            }, [
+              S[2] || (S[2] = O("span", { class: "v-craft-drop-text-label" }, "Drop a component here", -1)),
+              O("span", yr, ne(H), 1)
+            ], 40, gr)) : x("", !0),
+            I.value ? (v(), E(T, { key: 1 }, [
+              u.value?.type && u.value.slotName === H ? (v(!0), E(T, { key: 0 }, M(J(r.value.slots?.[H] || [], H), (L) => (v(), N(B, {
+                key: L.key,
+                craftNode: L.craftNode
+              }, null, 8, ["craftNode"]))), 128)) : x("", !0),
+              (v(!0), E(T, null, M(r.value.slots?.[H] || [], (L) => (v(), N(Q, {
+                key: L.uuid,
+                craftNode: L
+              }, null, 8, ["craftNode"]))), 128))
+            ], 64)) : x("", !0)
+          ])
+        }))
+      ]), 1040, ["data-node-name", "style", "class", "draggable", "onDragend", "onDragover", "onDragstart", "onDrop"])) : x("", !0);
+    };
+  }
+}), ve = /* @__PURE__ */ $({
+  name: "CraftNodeViewer",
+  __name: "CraftNodeViewer",
+  props: {
+    craftNode: {},
+    nodeDataMap: {},
+    eventsContext: {}
+  },
+  setup(t) {
+    const e = t, r = ce(e, "craftNode"), { editor: n, visible: s } = Ze(r), { resolvedNode: o, defaultProps: i, resolver: a } = xe(r);
+    re("resolver", a);
+    const c = w(() => ({
+      ...i.value,
+      ...r.value?.props
+    })), u = w(() => e.nodeDataMap?.[r.value.uuid] || n?.nodeDataMap?.[r.value.uuid]), d = w(() => r.value.slots || {}), h = w(() => q(r.value)), m = w(() => {
+      const A = [], R = a?.value?.resolveNode?.(r.value)?.slots;
+      return R && R.length > 0 ? A.push(...R) : A.push("default"), A;
+    }), p = w(() => h.value ? !0 : Object.values(d.value).some((A) => A.length > 0)), b = (A, z) => u.value ? u.value.slotName && u.value.slotName !== z ? [] : F(u.value, A) : [], g = K(null), { eventHandlers: D } = Ge(
+      r,
+      n,
+      e.eventsContext || n?.eventsContext || {}
+    );
+    Ne(() => {
+      g.value && r.value && n && n.setNodeRef(r.value, g.value);
+    });
+    const F = (A, z) => A.type === "single" ? z.map((R) => ({
+      key: `${R.uuid}-single`,
+      craftNode: {
+        ...R,
+        props: {
+          ...R.props,
+          ...A.item || {}
+        }
+      }
+    })) : A.type === "list" ? A.list ? z.reduce((R, y) => R.concat(
+      //@ts-ignore
+      A.list.map((k, I) => ({
+        key: `${y.uuid}-data-${I}`,
+        craftNode: {
+          ...y,
+          props: {
+            ...y.props,
+            ...k || {}
+          }
+        }
+      }))
+    ), []) : [] : [];
+    return (A, z) => f(s) && f(a) && f(o) ? (v(), N(me(f(o).componentName), Oe({
+      key: 0,
+      ref_key: "nodeRef",
+      ref: g
+    }, c.value, Fe(f(D))), ge({ _: 2 }, [
+      M(m.value, (R) => ({
+        name: R,
+        fn: X(() => [
+          p.value ? (v(), E(T, { key: 0 }, [
+            u.value?.type ? (v(!0), E(T, { key: 1 }, M(b(d.value[R], R), (y) => (v(), N(ve, {
+              key: y.key,
+              craftNode: y.craftNode
+            }, null, 8, ["craftNode"]))), 128)) : (v(!0), E(T, { key: 0 }, M(d.value[R], (y) => (v(), N(ve, {
+              key: y.uuid,
+              craftNode: y
+            }, null, 8, ["craftNode"]))), 128))
+          ], 64)) : x("", !0)
+        ])
+      }))
+    ]), 1040)) : x("", !0);
+  }
+}), Er = /* @__PURE__ */ $({
+  name: "CraftStaticRenderer",
+  __name: "CraftStaticRenderer",
+  props: {
+    nodes: {},
+    resolverMap: {},
+    nodeDataMap: {},
+    eventsContext: {}
+  },
+  setup(t) {
+    const e = t, r = w(() => new ye(e.resolverMap));
+    return re("resolver", r), re("nodeDataMap", e.nodeDataMap || {}), re("eventsContext", e.eventsContext || {}), (n, s) => (v(!0), E(T, null, M(t.nodes, (o) => (v(), N(ve, {
+      key: o.uuid,
+      craftNode: o,
+      nodeDataMap: t.nodeDataMap,
+      eventsContext: t.eventsContext
+    }, null, 8, ["craftNode", "nodeDataMap", "eventsContext"]))), 128));
+  }
+}), Ie = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  CraftCanvas: vt,
+  CraftComponentSimpleText: Et,
+  CraftEditor: Ct,
+  CraftEditorBlueprint: wt,
+  CraftEditorBlueprintsList: At,
+  CraftEditorPanelBlueprints: $t,
+  CraftEditorPanelForm: Rt,
+  CraftEditorPanelLayers: Bt,
+  CraftEditorPanelLayout: Xt,
+  CraftEditorPanelNodeEventsSettings: qt,
+  CraftEditorPanelNodeLayer: Zt,
+  CraftEditorPanelNodeSettings: er,
+  CraftEditorPanelSettings: ir,
+  CraftFrame: cr,
+  CraftIframe: Qe,
+  CraftNodeEditor: br,
+  CraftNodeViewer: ve,
+  CraftStaticRenderer: Er,
+  Utils: _t
+}, Symbol.toStringTag, { value: "Module" })), Vr = {
+  metadata: {
+    name: "default"
+  },
+  label: "Default",
+  blueprints: {
+    CraftComponentSimpleText: {
+      label: "Text",
+      componentName: "CraftComponentSimpleText",
+      props: {
+        content: "Lorem ipsum dolor sit amet, consectetur adipiscing elit. Aenean luctus arcu eu justo cursus faucibus. Phasellus non ex ac massa aliquet suscipit non eget odio. Aliquam eget laoreet ligula, at imperdiet tortor. Integer ut eros non velit rhoncus tincidunt. Mauris porta fringilla volutpat. Duis et nulla leo. Cras eu risus at nisl feugiat commodo vitae vel augue. Aenean at tempus velit. Duis eget convallis ipsum, eget suscipit felis. Quisque scelerisque euismod scelerisque.",
+        componentName: "p"
+      }
+    }
+  }
+};
+class Cr {
+  /**
+   * @callback HookCallback
+   * @this {*|Jsep} this
+   * @param {Jsep} env
+   * @returns: void
+   */
+  /**
+   * Adds the given callback to the list of callbacks for the given hook.
+   *
+   * The callback will be invoked when the hook it is registered for is run.
+   *
+   * One callback function can be registered to multiple hooks and the same hook multiple times.
+   *
+   * @param {string|object} name The name of the hook, or an object of callbacks keyed by name
+   * @param {HookCallback|boolean} callback The callback function which is given environment variables.
+   * @param {?boolean} [first=false] Will add the hook to the top of the list (defaults to the bottom)
+   * @public
+   */
+  add(e, r, n) {
+    if (typeof arguments[0] != "string")
+      for (let s in arguments[0])
+        this.add(s, arguments[0][s], arguments[1]);
+    else
+      (Array.isArray(e) ? e : [e]).forEach(function(s) {
+        this[s] = this[s] || [], r && this[s][n ? "unshift" : "push"](r);
+      }, this);
+  }
+  /**
+   * Runs a hook invoking all registered callbacks with the given environment variables.
+   *
+   * Callbacks will be invoked synchronously and in the order in which they were registered.
+   *
+   * @param {string} name The name of the hook.
+   * @param {Object<string, any>} env The environment variables of the hook passed to all callbacks registered.
+   * @public
+   */
+  run(e, r) {
+    this[e] = this[e] || [], this[e].forEach(function(n) {
+      n.call(r && r.context ? r.context : r, r);
+    });
+  }
+}
+class wr {
+  constructor(e) {
+    this.jsep = e, this.registered = {};
+  }
+  /**
+   * @callback PluginSetup
+   * @this {Jsep} jsep
+   * @returns: void
+   */
+  /**
+   * Adds the given plugin(s) to the registry
+   *
+   * @param {object} plugins
+   * @param {string} plugins.name The name of the plugin
+   * @param {PluginSetup} plugins.init The init function
+   * @public
+   */
+  register() {
+    for (var e = arguments.length, r = new Array(e), n = 0; n < e; n++)
+      r[n] = arguments[n];
+    r.forEach((s) => {
+      if (typeof s != "object" || !s.name || !s.init)
+        throw new Error("Invalid JSEP plugin format");
+      this.registered[s.name] || (s.init(this.jsep), this.registered[s.name] = s);
+    });
+  }
+}
+class l {
+  /**
+   * @returns {string}
+   */
+  static get version() {
+    return "1.4.0";
+  }
+  /**
+   * @returns {string}
+   */
+  static toString() {
+    return "JavaScript Expression Parser (JSEP) v" + l.version;
+  }
+  // ==================== CONFIG ================================
+  /**
+   * @method addUnaryOp
+   * @param {string} op_name The name of the unary op to add
+   * @returns {Jsep}
+   */
+  static addUnaryOp(e) {
+    return l.max_unop_len = Math.max(e.length, l.max_unop_len), l.unary_ops[e] = 1, l;
+  }
+  /**
+   * @method jsep.addBinaryOp
+   * @param {string} op_name The name of the binary op to add
+   * @param {number} precedence The precedence of the binary op (can be a float). Higher number = higher precedence
+   * @param {boolean} [isRightAssociative=false] whether operator is right-associative
+   * @returns {Jsep}
+   */
+  static addBinaryOp(e, r, n) {
+    return l.max_binop_len = Math.max(e.length, l.max_binop_len), l.binary_ops[e] = r, n ? l.right_associative.add(e) : l.right_associative.delete(e), l;
+  }
+  /**
+   * @method addIdentifierChar
+   * @param {string} char The additional character to treat as a valid part of an identifier
+   * @returns {Jsep}
+   */
+  static addIdentifierChar(e) {
+    return l.additional_identifier_chars.add(e), l;
+  }
+  /**
+   * @method addLiteral
+   * @param {string} literal_name The name of the literal to add
+   * @param {*} literal_value The value of the literal
+   * @returns {Jsep}
+   */
+  static addLiteral(e, r) {
+    return l.literals[e] = r, l;
+  }
+  /**
+   * @method removeUnaryOp
+   * @param {string} op_name The name of the unary op to remove
+   * @returns {Jsep}
+   */
+  static removeUnaryOp(e) {
+    return delete l.unary_ops[e], e.length === l.max_unop_len && (l.max_unop_len = l.getMaxKeyLen(l.unary_ops)), l;
+  }
+  /**
+   * @method removeAllUnaryOps
+   * @returns {Jsep}
+   */
+  static removeAllUnaryOps() {
+    return l.unary_ops = {}, l.max_unop_len = 0, l;
+  }
+  /**
+   * @method removeIdentifierChar
+   * @param {string} char The additional character to stop treating as a valid part of an identifier
+   * @returns {Jsep}
+   */
+  static removeIdentifierChar(e) {
+    return l.additional_identifier_chars.delete(e), l;
+  }
+  /**
+   * @method removeBinaryOp
+   * @param {string} op_name The name of the binary op to remove
+   * @returns {Jsep}
+   */
+  static removeBinaryOp(e) {
+    return delete l.binary_ops[e], e.length === l.max_binop_len && (l.max_binop_len = l.getMaxKeyLen(l.binary_ops)), l.right_associative.delete(e), l;
+  }
+  /**
+   * @method removeAllBinaryOps
+   * @returns {Jsep}
+   */
+  static removeAllBinaryOps() {
+    return l.binary_ops = {}, l.max_binop_len = 0, l;
+  }
+  /**
+   * @method removeLiteral
+   * @param {string} literal_name The name of the literal to remove
+   * @returns {Jsep}
+   */
+  static removeLiteral(e) {
+    return delete l.literals[e], l;
+  }
+  /**
+   * @method removeAllLiterals
+   * @returns {Jsep}
+   */
+  static removeAllLiterals() {
+    return l.literals = {}, l;
+  }
+  // ==================== END CONFIG ============================
+  /**
+   * @returns {string}
+   */
+  get char() {
+    return this.expr.charAt(this.index);
+  }
+  /**
+   * @returns {number}
+   */
+  get code() {
+    return this.expr.charCodeAt(this.index);
+  }
+  /**
+   * @param {string} expr a string with the passed in express
+   * @returns Jsep
+   */
+  constructor(e) {
+    this.expr = e, this.index = 0;
+  }
+  /**
+   * static top-level parser
+   * @returns {jsep.Expression}
+   */
+  static parse(e) {
+    return new l(e).parse();
+  }
+  /**
+   * Get the longest key length of any object
+   * @param {object} obj
+   * @returns {number}
+   */
+  static getMaxKeyLen(e) {
+    return Math.max(0, ...Object.keys(e).map((r) => r.length));
+  }
+  /**
+   * `ch` is a character code in the next three functions
+   * @param {number} ch
+   * @returns {boolean}
+   */
+  static isDecimalDigit(e) {
+    return e >= 48 && e <= 57;
+  }
+  /**
+   * Returns the precedence of a binary operator or `0` if it isn't a binary operator. Can be float.
+   * @param {string} op_val
+   * @returns {number}
+   */
+  static binaryPrecedence(e) {
+    return l.binary_ops[e] || 0;
+  }
+  /**
+   * Looks for start of identifier
+   * @param {number} ch
+   * @returns {boolean}
+   */
+  static isIdentifierStart(e) {
+    return e >= 65 && e <= 90 || // A...Z
+    e >= 97 && e <= 122 || // a...z
+    e >= 128 && !l.binary_ops[String.fromCharCode(e)] || // any non-ASCII that is not an operator
+    l.additional_identifier_chars.has(String.fromCharCode(e));
+  }
+  /**
+   * @param {number} ch
+   * @returns {boolean}
+   */
+  static isIdentifierPart(e) {
+    return l.isIdentifierStart(e) || l.isDecimalDigit(e);
+  }
+  /**
+   * throw error at index of the expression
+   * @param {string} message
+   * @throws
+   */
+  throwError(e) {
+    const r = new Error(e + " at character " + this.index);
+    throw r.index = this.index, r.description = e, r;
+  }
+  /**
+   * Run a given hook
+   * @param {string} name
+   * @param {jsep.Expression|false} [node]
+   * @returns {?jsep.Expression}
+   */
+  runHook(e, r) {
+    if (l.hooks[e]) {
+      const n = {
+        context: this,
+        node: r
+      };
+      return l.hooks.run(e, n), n.node;
+    }
+    return r;
+  }
+  /**
+   * Runs a given hook until one returns a node
+   * @param {string} name
+   * @returns {?jsep.Expression}
+   */
+  searchHook(e) {
+    if (l.hooks[e]) {
+      const r = {
+        context: this
+      };
+      return l.hooks[e].find(function(n) {
+        return n.call(r.context, r), r.node;
+      }), r.node;
+    }
+  }
+  /**
+   * Push `index` up to the next non-space character
+   */
+  gobbleSpaces() {
+    let e = this.code;
+    for (; e === l.SPACE_CODE || e === l.TAB_CODE || e === l.LF_CODE || e === l.CR_CODE; )
+      e = this.expr.charCodeAt(++this.index);
+    this.runHook("gobble-spaces");
+  }
+  /**
+   * Top-level method to parse all expressions and returns compound or single node
+   * @returns {jsep.Expression}
+   */
+  parse() {
+    this.runHook("before-all");
+    const e = this.gobbleExpressions(), r = e.length === 1 ? e[0] : {
+      type: l.COMPOUND,
+      body: e
+    };
+    return this.runHook("after-all", r);
+  }
+  /**
+   * top-level parser (but can be reused within as well)
+   * @param {number} [untilICode]
+   * @returns {jsep.Expression[]}
+   */
+  gobbleExpressions(e) {
+    let r = [], n, s;
+    for (; this.index < this.expr.length; )
+      if (n = this.code, n === l.SEMCOL_CODE || n === l.COMMA_CODE)
+        this.index++;
+      else if (s = this.gobbleExpression())
+        r.push(s);
+      else if (this.index < this.expr.length) {
+        if (n === e)
+          break;
+        this.throwError('Unexpected "' + this.char + '"');
+      }
+    return r;
+  }
+  /**
+   * The main parsing function.
+   * @returns {?jsep.Expression}
+   */
+  gobbleExpression() {
+    const e = this.searchHook("gobble-expression") || this.gobbleBinaryExpression();
+    return this.gobbleSpaces(), this.runHook("after-expression", e);
+  }
+  /**
+   * Search for the operation portion of the string (e.g. `+`, `===`)
+   * Start by taking the longest possible binary operations (3 characters: `===`, `!==`, `>>>`)
+   * and move down from 3 to 2 to 1 character until a matching binary operation is found
+   * then, return that binary operation
+   * @returns {string|boolean}
+   */
+  gobbleBinaryOp() {
+    this.gobbleSpaces();
+    let e = this.expr.substr(this.index, l.max_binop_len), r = e.length;
+    for (; r > 0; ) {
+      if (l.binary_ops.hasOwnProperty(e) && (!l.isIdentifierStart(this.code) || this.index + e.length < this.expr.length && !l.isIdentifierPart(this.expr.charCodeAt(this.index + e.length))))
+        return this.index += r, e;
+      e = e.substr(0, --r);
+    }
+    return !1;
+  }
+  /**
+   * This function is responsible for gobbling an individual expression,
+   * e.g. `1`, `1+2`, `a+(b*2)-Math.sqrt(2)`
+   * @returns {?jsep.BinaryExpression}
+   */
+  gobbleBinaryExpression() {
+    let e, r, n, s, o, i, a, c, u;
+    if (i = this.gobbleToken(), !i || (r = this.gobbleBinaryOp(), !r))
+      return i;
+    for (o = {
+      value: r,
+      prec: l.binaryPrecedence(r),
+      right_a: l.right_associative.has(r)
+    }, a = this.gobbleToken(), a || this.throwError("Expected expression after " + r), s = [i, o, a]; r = this.gobbleBinaryOp(); ) {
+      if (n = l.binaryPrecedence(r), n === 0) {
+        this.index -= r.length;
+        break;
+      }
+      o = {
+        value: r,
+        prec: n,
+        right_a: l.right_associative.has(r)
+      }, u = r;
+      const d = (h) => o.right_a && h.right_a ? n > h.prec : n <= h.prec;
+      for (; s.length > 2 && d(s[s.length - 2]); )
+        a = s.pop(), r = s.pop().value, i = s.pop(), e = {
+          type: l.BINARY_EXP,
+          operator: r,
+          left: i,
+          right: a
+        }, s.push(e);
+      e = this.gobbleToken(), e || this.throwError("Expected expression after " + u), s.push(o, e);
+    }
+    for (c = s.length - 1, e = s[c]; c > 1; )
+      e = {
+        type: l.BINARY_EXP,
+        operator: s[c - 1].value,
+        left: s[c - 2],
+        right: e
+      }, c -= 2;
+    return e;
+  }
+  /**
+   * An individual part of a binary expression:
+   * e.g. `foo.bar(baz)`, `1`, `"abc"`, `(a % 2)` (because it's in parenthesis)
+   * @returns {boolean|jsep.Expression}
+   */
+  gobbleToken() {
+    let e, r, n, s;
+    if (this.gobbleSpaces(), s = this.searchHook("gobble-token"), s)
+      return this.runHook("after-token", s);
+    if (e = this.code, l.isDecimalDigit(e) || e === l.PERIOD_CODE)
+      return this.gobbleNumericLiteral();
+    if (e === l.SQUOTE_CODE || e === l.DQUOTE_CODE)
+      s = this.gobbleStringLiteral();
+    else if (e === l.OBRACK_CODE)
+      s = this.gobbleArray();
+    else {
+      for (r = this.expr.substr(this.index, l.max_unop_len), n = r.length; n > 0; ) {
+        if (l.unary_ops.hasOwnProperty(r) && (!l.isIdentifierStart(this.code) || this.index + r.length < this.expr.length && !l.isIdentifierPart(this.expr.charCodeAt(this.index + r.length)))) {
+          this.index += n;
+          const o = this.gobbleToken();
+          return o || this.throwError("missing unaryOp argument"), this.runHook("after-token", {
+            type: l.UNARY_EXP,
+            operator: r,
+            argument: o,
+            prefix: !0
+          });
+        }
+        r = r.substr(0, --n);
+      }
+      l.isIdentifierStart(e) ? (s = this.gobbleIdentifier(), l.literals.hasOwnProperty(s.name) ? s = {
+        type: l.LITERAL,
+        value: l.literals[s.name],
+        raw: s.name
+      } : s.name === l.this_str && (s = {
+        type: l.THIS_EXP
+      })) : e === l.OPAREN_CODE && (s = this.gobbleGroup());
+    }
+    return s ? (s = this.gobbleTokenProperty(s), this.runHook("after-token", s)) : this.runHook("after-token", !1);
+  }
+  /**
+   * Gobble properties of of identifiers/strings/arrays/groups.
+   * e.g. `foo`, `bar.baz`, `foo['bar'].baz`
+   * It also gobbles function calls:
+   * e.g. `Math.acos(obj.angle)`
+   * @param {jsep.Expression} node
+   * @returns {jsep.Expression}
+   */
+  gobbleTokenProperty(e) {
+    this.gobbleSpaces();
+    let r = this.code;
+    for (; r === l.PERIOD_CODE || r === l.OBRACK_CODE || r === l.OPAREN_CODE || r === l.QUMARK_CODE; ) {
+      let n;
+      if (r === l.QUMARK_CODE) {
+        if (this.expr.charCodeAt(this.index + 1) !== l.PERIOD_CODE)
+          break;
+        n = !0, this.index += 2, this.gobbleSpaces(), r = this.code;
+      }
+      this.index++, r === l.OBRACK_CODE ? (e = {
+        type: l.MEMBER_EXP,
+        computed: !0,
+        object: e,
+        property: this.gobbleExpression()
+      }, e.property || this.throwError('Unexpected "' + this.char + '"'), this.gobbleSpaces(), r = this.code, r !== l.CBRACK_CODE && this.throwError("Unclosed ["), this.index++) : r === l.OPAREN_CODE ? e = {
+        type: l.CALL_EXP,
+        arguments: this.gobbleArguments(l.CPAREN_CODE),
+        callee: e
+      } : (r === l.PERIOD_CODE || n) && (n && this.index--, this.gobbleSpaces(), e = {
+        type: l.MEMBER_EXP,
+        computed: !1,
+        object: e,
+        property: this.gobbleIdentifier()
+      }), n && (e.optional = !0), this.gobbleSpaces(), r = this.code;
+    }
+    return e;
+  }
+  /**
+   * Parse simple numeric literals: `12`, `3.4`, `.5`. Do this by using a string to
+   * keep track of everything in the numeric literal and then calling `parseFloat` on that string
+   * @returns {jsep.Literal}
+   */
+  gobbleNumericLiteral() {
+    let e = "", r, n;
+    for (; l.isDecimalDigit(this.code); )
+      e += this.expr.charAt(this.index++);
+    if (this.code === l.PERIOD_CODE)
+      for (e += this.expr.charAt(this.index++); l.isDecimalDigit(this.code); )
+        e += this.expr.charAt(this.index++);
+    if (r = this.char, r === "e" || r === "E") {
+      for (e += this.expr.charAt(this.index++), r = this.char, (r === "+" || r === "-") && (e += this.expr.charAt(this.index++)); l.isDecimalDigit(this.code); )
+        e += this.expr.charAt(this.index++);
+      l.isDecimalDigit(this.expr.charCodeAt(this.index - 1)) || this.throwError("Expected exponent (" + e + this.char + ")");
+    }
+    return n = this.code, l.isIdentifierStart(n) ? this.throwError("Variable names cannot start with a number (" + e + this.char + ")") : (n === l.PERIOD_CODE || e.length === 1 && e.charCodeAt(0) === l.PERIOD_CODE) && this.throwError("Unexpected period"), {
+      type: l.LITERAL,
+      value: parseFloat(e),
+      raw: e
+    };
+  }
+  /**
+   * Parses a string literal, staring with single or double quotes with basic support for escape codes
+   * e.g. `"hello world"`, `'this is\nJSEP'`
+   * @returns {jsep.Literal}
+   */
+  gobbleStringLiteral() {
+    let e = "";
+    const r = this.index, n = this.expr.charAt(this.index++);
+    let s = !1;
+    for (; this.index < this.expr.length; ) {
+      let o = this.expr.charAt(this.index++);
+      if (o === n) {
+        s = !0;
+        break;
+      } else if (o === "\\")
+        switch (o = this.expr.charAt(this.index++), o) {
+          case "n":
+            e += `
+`;
+            break;
+          case "r":
+            e += "\r";
+            break;
+          case "t":
+            e += "	";
+            break;
+          case "b":
+            e += "\b";
+            break;
+          case "f":
+            e += "\f";
+            break;
+          case "v":
+            e += "\v";
+            break;
+          default:
+            e += o;
+        }
+      else
+        e += o;
+    }
+    return s || this.throwError('Unclosed quote after "' + e + '"'), {
+      type: l.LITERAL,
+      value: e,
+      raw: this.expr.substring(r, this.index)
+    };
+  }
+  /**
+   * Gobbles only identifiers
+   * e.g.: `foo`, `_value`, `$x1`
+   * Also, this function checks if that identifier is a literal:
+   * (e.g. `true`, `false`, `null`) or `this`
+   * @returns {jsep.Identifier}
+   */
+  gobbleIdentifier() {
+    let e = this.code, r = this.index;
+    for (l.isIdentifierStart(e) ? this.index++ : this.throwError("Unexpected " + this.char); this.index < this.expr.length && (e = this.code, l.isIdentifierPart(e)); )
+      this.index++;
+    return {
+      type: l.IDENTIFIER,
+      name: this.expr.slice(r, this.index)
+    };
+  }
+  /**
+   * Gobbles a list of arguments within the context of a function call
+   * or array literal. This function also assumes that the opening character
+   * `(` or `[` has already been gobbled, and gobbles expressions and commas
+   * until the terminator character `)` or `]` is encountered.
+   * e.g. `foo(bar, baz)`, `my_func()`, or `[bar, baz]`
+   * @param {number} termination
+   * @returns {jsep.Expression[]}
+   */
+  gobbleArguments(e) {
+    const r = [];
+    let n = !1, s = 0;
+    for (; this.index < this.expr.length; ) {
+      this.gobbleSpaces();
+      let o = this.code;
+      if (o === e) {
+        n = !0, this.index++, e === l.CPAREN_CODE && s && s >= r.length && this.throwError("Unexpected token " + String.fromCharCode(e));
+        break;
+      } else if (o === l.COMMA_CODE) {
+        if (this.index++, s++, s !== r.length) {
+          if (e === l.CPAREN_CODE)
+            this.throwError("Unexpected token ,");
+          else if (e === l.CBRACK_CODE)
+            for (let i = r.length; i < s; i++)
+              r.push(null);
+        }
+      } else if (r.length !== s && s !== 0)
+        this.throwError("Expected comma");
+      else {
+        const i = this.gobbleExpression();
+        (!i || i.type === l.COMPOUND) && this.throwError("Expected comma"), r.push(i);
+      }
+    }
+    return n || this.throwError("Expected " + String.fromCharCode(e)), r;
+  }
+  /**
+   * Responsible for parsing a group of things within parentheses `()`
+   * that have no identifier in front (so not a function call)
+   * This function assumes that it needs to gobble the opening parenthesis
+   * and then tries to gobble everything within that parenthesis, assuming
+   * that the next thing it should see is the close parenthesis. If not,
+   * then the expression probably doesn't have a `)`
+   * @returns {boolean|jsep.Expression}
+   */
+  gobbleGroup() {
+    this.index++;
+    let e = this.gobbleExpressions(l.CPAREN_CODE);
+    if (this.code === l.CPAREN_CODE)
+      return this.index++, e.length === 1 ? e[0] : e.length ? {
+        type: l.SEQUENCE_EXP,
+        expressions: e
+      } : !1;
+    this.throwError("Unclosed (");
+  }
+  /**
+   * Responsible for parsing Array literals `[1, 2, 3]`
+   * This function assumes that it needs to gobble the opening bracket
+   * and then tries to gobble the expressions as arguments.
+   * @returns {jsep.ArrayExpression}
+   */
+  gobbleArray() {
+    return this.index++, {
+      type: l.ARRAY_EXP,
+      elements: this.gobbleArguments(l.CBRACK_CODE)
+    };
+  }
+}
+const _r = new Cr();
+Object.assign(l, {
+  hooks: _r,
+  plugins: new wr(l),
+  // Node Types
+  // ----------
+  // This is the full set of types that any JSEP node can be.
+  // Store them here to save space when minified
+  COMPOUND: "Compound",
+  SEQUENCE_EXP: "SequenceExpression",
+  IDENTIFIER: "Identifier",
+  MEMBER_EXP: "MemberExpression",
+  LITERAL: "Literal",
+  THIS_EXP: "ThisExpression",
+  CALL_EXP: "CallExpression",
+  UNARY_EXP: "UnaryExpression",
+  BINARY_EXP: "BinaryExpression",
+  ARRAY_EXP: "ArrayExpression",
+  TAB_CODE: 9,
+  LF_CODE: 10,
+  CR_CODE: 13,
+  SPACE_CODE: 32,
+  PERIOD_CODE: 46,
+  // '.'
+  COMMA_CODE: 44,
+  // ','
+  SQUOTE_CODE: 39,
+  // single quote
+  DQUOTE_CODE: 34,
+  // double quotes
+  OPAREN_CODE: 40,
+  // (
+  CPAREN_CODE: 41,
+  // )
+  OBRACK_CODE: 91,
+  // [
+  CBRACK_CODE: 93,
+  // ]
+  QUMARK_CODE: 63,
+  // ?
+  SEMCOL_CODE: 59,
+  // ;
+  COLON_CODE: 58,
+  // :
+  // Operations
+  // ----------
+  // Use a quickly-accessible map to store all of the unary operators
+  // Values are set to `1` (it really doesn't matter)
+  unary_ops: {
+    "-": 1,
+    "!": 1,
+    "~": 1,
+    "+": 1
+  },
+  // Also use a map for the binary operations but set their values to their
+  // binary precedence for quick reference (higher number = higher precedence)
+  // see [Order of operations](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Operator_Precedence)
+  binary_ops: {
+    "||": 1,
+    "??": 1,
+    "&&": 2,
+    "|": 3,
+    "^": 4,
+    "&": 5,
+    "==": 6,
+    "!=": 6,
+    "===": 6,
+    "!==": 6,
+    "<": 7,
+    ">": 7,
+    "<=": 7,
+    ">=": 7,
+    "<<": 8,
+    ">>": 8,
+    ">>>": 8,
+    "+": 9,
+    "-": 9,
+    "*": 10,
+    "/": 10,
+    "%": 10,
+    "**": 11
+  },
+  // sets specific binary_ops as right-associative
+  right_associative: /* @__PURE__ */ new Set(["**"]),
+  // Additional valid identifier chars, apart from a-z, A-Z and 0-9 (except on the starting char)
+  additional_identifier_chars: /* @__PURE__ */ new Set(["$", "_"]),
+  // Literals
+  // ----------
+  // Store the values to return for the various literals we may encounter
+  literals: {
+    true: !0,
+    false: !1,
+    null: null
+  },
+  // Except for `this`, which is special. This could be changed to something like `'self'` as well
+  this_str: "this"
+});
+l.max_unop_len = l.getMaxKeyLen(l.unary_ops);
+l.max_binop_len = l.getMaxKeyLen(l.binary_ops);
+const Y = (t) => new l(t).parse(), Or = Object.getOwnPropertyNames(class {
+});
+Object.getOwnPropertyNames(l).filter((t) => !Or.includes(t) && Y[t] === void 0).forEach((t) => {
+  Y[t] = l[t];
+});
+Y.Jsep = l;
+const Nr = "ConditionalExpression";
+var xr = {
+  name: "ternary",
+  init(t) {
+    t.hooks.add("after-expression", function(r) {
+      if (r.node && this.code === t.QUMARK_CODE) {
+        this.index++;
+        const n = r.node, s = this.gobbleExpression();
+        if (s || this.throwError("Expected expression"), this.gobbleSpaces(), this.code === t.COLON_CODE) {
+          this.index++;
+          const o = this.gobbleExpression();
+          if (o || this.throwError("Expected expression"), r.node = {
+            type: Nr,
+            test: n,
+            consequent: s,
+            alternate: o
+          }, n.operator && t.binary_ops[n.operator] <= 0.9) {
+            let i = n;
+            for (; i.right.operator && t.binary_ops[i.right.operator] <= 0.9; )
+              i = i.right;
+            r.node.test = i.right, i.right = r.node, r.node = n;
+          }
+        } else
+          this.throwError("Expected :");
+      }
+    });
+  }
+};
+Y.plugins.register(xr);
+const Me = 47, Sr = 92;
+var Ar = {
+  name: "regex",
+  init(t) {
+    t.hooks.add("gobble-token", function(r) {
+      if (this.code === Me) {
+        const n = ++this.index;
+        let s = !1;
+        for (; this.index < this.expr.length; ) {
+          if (this.code === Me && !s) {
+            const o = this.expr.slice(n, this.index);
+            let i = "";
+            for (; ++this.index < this.expr.length; ) {
+              const c = this.code;
+              if (c >= 97 && c <= 122 || c >= 65 && c <= 90 || c >= 48 && c <= 57)
+                i += this.char;
+              else
+                break;
+            }
+            let a;
+            try {
+              a = new RegExp(o, i);
+            } catch (c) {
+              this.throwError(c.message);
+            }
+            return r.node = {
+              type: t.LITERAL,
+              value: a,
+              raw: this.expr.slice(n - 1, this.index)
+            }, r.node = this.gobbleTokenProperty(r.node), r.node;
+          }
+          this.code === t.OBRACK_CODE ? s = !0 : s && this.code === t.CBRACK_CODE && (s = !1), this.index += this.code === Sr ? 2 : 1;
+        }
+        this.throwError("Unclosed Regex");
+      }
+    });
+  }
+};
+const Ee = 43, Pr = 45, se = {
+  name: "assignment",
+  assignmentOperators: /* @__PURE__ */ new Set(["=", "*=", "**=", "/=", "%=", "+=", "-=", "<<=", ">>=", ">>>=", "&=", "^=", "|=", "||=", "&&=", "??="]),
+  updateOperators: [Ee, Pr],
+  assignmentPrecedence: 0.9,
+  init(t) {
+    const e = [t.IDENTIFIER, t.MEMBER_EXP];
+    se.assignmentOperators.forEach((n) => t.addBinaryOp(n, se.assignmentPrecedence, !0)), t.hooks.add("gobble-token", function(s) {
+      const o = this.code;
+      se.updateOperators.some((i) => i === o && i === this.expr.charCodeAt(this.index + 1)) && (this.index += 2, s.node = {
+        type: "UpdateExpression",
+        operator: o === Ee ? "++" : "--",
+        argument: this.gobbleTokenProperty(this.gobbleIdentifier()),
+        prefix: !0
+      }, (!s.node.argument || !e.includes(s.node.argument.type)) && this.throwError(`Unexpected ${s.node.operator}`));
+    }), t.hooks.add("after-token", function(s) {
+      if (s.node) {
+        const o = this.code;
+        se.updateOperators.some((i) => i === o && i === this.expr.charCodeAt(this.index + 1)) && (e.includes(s.node.type) || this.throwError(`Unexpected ${s.node.operator}`), this.index += 2, s.node = {
+          type: "UpdateExpression",
+          operator: o === Ee ? "++" : "--",
+          argument: s.node,
+          prefix: !1
+        });
+      }
+    }), t.hooks.add("after-expression", function(s) {
+      s.node && r(s.node);
+    });
+    function r(n) {
+      se.assignmentOperators.has(n.operator) ? (n.type = "AssignmentExpression", r(n.left), r(n.right)) : n.operator || Object.values(n).forEach((s) => {
+        s && typeof s == "object" && r(s);
+      });
+    }
+  }
+};
+Y.plugins.register(Ar, se);
+Y.addUnaryOp("typeof");
+Y.addUnaryOp("void");
+Y.addLiteral("null", null);
+Y.addLiteral("undefined", void 0);
+const Dr = /* @__PURE__ */ new Set(["constructor", "__proto__", "__defineGetter__", "__defineSetter__", "__lookupGetter__", "__lookupSetter__"]), _ = {
+  /**
+   * @param {jsep.Expression} ast
+   * @param {Record<string, any>} subs
+   */
+  evalAst(t, e) {
+    switch (t.type) {
+      case "BinaryExpression":
+      case "LogicalExpression":
+        return _.evalBinaryExpression(t, e);
+      case "Compound":
+        return _.evalCompound(t, e);
+      case "ConditionalExpression":
+        return _.evalConditionalExpression(t, e);
+      case "Identifier":
+        return _.evalIdentifier(t, e);
+      case "Literal":
+        return _.evalLiteral(t, e);
+      case "MemberExpression":
+        return _.evalMemberExpression(t, e);
+      case "UnaryExpression":
+        return _.evalUnaryExpression(t, e);
+      case "ArrayExpression":
+        return _.evalArrayExpression(t, e);
+      case "CallExpression":
+        return _.evalCallExpression(t, e);
+      case "AssignmentExpression":
+        return _.evalAssignmentExpression(t, e);
+      default:
+        throw SyntaxError("Unexpected expression", t);
+    }
+  },
+  evalBinaryExpression(t, e) {
+    return {
+      "||": (n, s) => n || s(),
+      "&&": (n, s) => n && s(),
+      "|": (n, s) => n | s(),
+      "^": (n, s) => n ^ s(),
+      "&": (n, s) => n & s(),
+      // eslint-disable-next-line eqeqeq -- API
+      "==": (n, s) => n == s(),
+      // eslint-disable-next-line eqeqeq -- API
+      "!=": (n, s) => n != s(),
+      "===": (n, s) => n === s(),
+      "!==": (n, s) => n !== s(),
+      "<": (n, s) => n < s(),
+      ">": (n, s) => n > s(),
+      "<=": (n, s) => n <= s(),
+      ">=": (n, s) => n >= s(),
+      "<<": (n, s) => n << s(),
+      ">>": (n, s) => n >> s(),
+      ">>>": (n, s) => n >>> s(),
+      "+": (n, s) => n + s(),
+      "-": (n, s) => n - s(),
+      "*": (n, s) => n * s(),
+      "/": (n, s) => n / s(),
+      "%": (n, s) => n % s()
+    }[t.operator](_.evalAst(t.left, e), () => _.evalAst(t.right, e));
+  },
+  evalCompound(t, e) {
+    let r;
+    for (let n = 0; n < t.body.length; n++) {
+      t.body[n].type === "Identifier" && ["var", "let", "const"].includes(t.body[n].name) && t.body[n + 1] && t.body[n + 1].type === "AssignmentExpression" && (n += 1);
+      const s = t.body[n];
+      r = _.evalAst(s, e);
+    }
+    return r;
+  },
+  evalConditionalExpression(t, e) {
+    return _.evalAst(t.test, e) ? _.evalAst(t.consequent, e) : _.evalAst(t.alternate, e);
+  },
+  evalIdentifier(t, e) {
+    if (Object.hasOwn(e, t.name))
+      return e[t.name];
+    throw ReferenceError(`${t.name} is not defined`);
+  },
+  evalLiteral(t) {
+    return t.value;
+  },
+  evalMemberExpression(t, e) {
+    const r = String(
+      // NOTE: `String(value)` throws error when
+      // value has overwritten the toString method to return non-string
+      // i.e. `value = {toString: () => []}`
+      t.computed ? _.evalAst(t.property) : t.property.name
+      // `object.property` property is Identifier
+    ), n = _.evalAst(t.object, e);
+    if (n == null)
+      throw TypeError(`Cannot read properties of ${n} (reading '${r}')`);
+    if (!Object.hasOwn(n, r) && Dr.has(r))
+      throw TypeError(`Cannot read properties of ${n} (reading '${r}')`);
+    const s = n[r];
+    return typeof s == "function" ? s.bind(n) : s;
+  },
+  evalUnaryExpression(t, e) {
+    return {
+      "-": (n) => -_.evalAst(n, e),
+      "!": (n) => !_.evalAst(n, e),
+      "~": (n) => ~_.evalAst(n, e),
+      // eslint-disable-next-line no-implicit-coercion -- API
+      "+": (n) => +_.evalAst(n, e),
+      typeof: (n) => typeof _.evalAst(n, e),
+      // eslint-disable-next-line no-void, sonarjs/void-use -- feature
+      void: (n) => void _.evalAst(n, e)
+    }[t.operator](t.argument);
+  },
+  evalArrayExpression(t, e) {
+    return t.elements.map((r) => _.evalAst(r, e));
+  },
+  evalCallExpression(t, e) {
+    const r = t.arguments.map((s) => _.evalAst(s, e)), n = _.evalAst(t.callee, e);
+    if (n === Function)
+      throw new Error("Function constructor is disabled");
+    return n(...r);
+  },
+  evalAssignmentExpression(t, e) {
+    if (t.left.type !== "Identifier")
+      throw SyntaxError("Invalid left-hand side in assignment");
+    const r = t.left.name, n = _.evalAst(t.right, e);
+    return e[r] = n, e[r];
+  }
+};
+class kr {
+  /**
+   * @param {string} expr Expression to evaluate
+   */
+  constructor(e) {
+    this.code = e, this.ast = Y(this.code);
+  }
+  /**
+   * @param {object} context Object whose items will be added
+   *   to evaluation
+   * @returns {EvaluatedResult} Result of evaluated code
+   */
+  runInNewContext(e) {
+    const r = Object.assign(/* @__PURE__ */ Object.create(null), e);
+    return _.evalAst(this.ast, r);
+  }
+}
+function ee(t, e) {
+  return t = t.slice(), t.push(e), t;
+}
+function we(t, e) {
+  return e = e.slice(), e.unshift(t), e;
+}
+class $r extends Error {
+  /**
+   * @param {AnyResult} value The evaluated scalar value
+   */
+  constructor(e) {
+    super('JSONPath should not be called with "new" (it prevents return of (unwrapped) scalar values)'), this.avoidNew = !0, this.value = e, this.name = "NewError";
+  }
+}
+function C(t, e, r, n, s) {
+  if (!(this instanceof C))
+    try {
+      return new C(t, e, r, n, s);
+    } catch (i) {
+      if (!i.avoidNew)
+        throw i;
+      return i.value;
+    }
+  typeof t == "string" && (s = n, n = r, r = e, e = t, t = null);
+  const o = t && typeof t == "object";
+  if (t = t || {}, this.json = t.json || r, this.path = t.path || e, this.resultType = t.resultType || "value", this.flatten = t.flatten || !1, this.wrap = Object.hasOwn(t, "wrap") ? t.wrap : !0, this.sandbox = t.sandbox || {}, this.eval = t.eval === void 0 ? "safe" : t.eval, this.ignoreEvalErrors = typeof t.ignoreEvalErrors > "u" ? !1 : t.ignoreEvalErrors, this.parent = t.parent || null, this.parentProperty = t.parentProperty || null, this.callback = t.callback || n || null, this.otherTypeCallback = t.otherTypeCallback || s || function() {
+    throw new TypeError("You must supply an otherTypeCallback callback option with the @other() operator.");
+  }, t.autostart !== !1) {
+    const i = {
+      path: o ? t.path : e
+    };
+    o ? "json" in t && (i.json = t.json) : i.json = r;
+    const a = this.evaluate(i);
+    if (!a || typeof a != "object")
+      throw new $r(a);
+    return a;
+  }
+}
+C.prototype.evaluate = function(t, e, r, n) {
+  let s = this.parent, o = this.parentProperty, {
+    flatten: i,
+    wrap: a
+  } = this;
+  if (this.currResultType = this.resultType, this.currEval = this.eval, this.currSandbox = this.sandbox, r = r || this.callback, this.currOtherTypeCallback = n || this.otherTypeCallback, e = e || this.json, t = t || this.path, t && typeof t == "object" && !Array.isArray(t)) {
+    if (!t.path && t.path !== "")
+      throw new TypeError('You must supply a "path" property when providing an object argument to JSONPath.evaluate().');
+    if (!Object.hasOwn(t, "json"))
+      throw new TypeError('You must supply a "json" property when providing an object argument to JSONPath.evaluate().');
+    ({
+      json: e
+    } = t), i = Object.hasOwn(t, "flatten") ? t.flatten : i, this.currResultType = Object.hasOwn(t, "resultType") ? t.resultType : this.currResultType, this.currSandbox = Object.hasOwn(t, "sandbox") ? t.sandbox : this.currSandbox, a = Object.hasOwn(t, "wrap") ? t.wrap : a, this.currEval = Object.hasOwn(t, "eval") ? t.eval : this.currEval, r = Object.hasOwn(t, "callback") ? t.callback : r, this.currOtherTypeCallback = Object.hasOwn(t, "otherTypeCallback") ? t.otherTypeCallback : this.currOtherTypeCallback, s = Object.hasOwn(t, "parent") ? t.parent : s, o = Object.hasOwn(t, "parentProperty") ? t.parentProperty : o, t = t.path;
+  }
+  if (s = s || null, o = o || null, Array.isArray(t) && (t = C.toPathString(t)), !t && t !== "" || !e)
+    return;
+  const c = C.toPathArray(t);
+  c[0] === "$" && c.length > 1 && c.shift(), this._hasParentSelector = null;
+  const u = this._trace(c, e, ["$"], s, o, r).filter(function(d) {
+    return d && !d.isParentSelector;
+  });
+  return u.length ? !a && u.length === 1 && !u[0].hasArrExpr ? this._getPreferredOutput(u[0]) : u.reduce((d, h) => {
+    const m = this._getPreferredOutput(h);
+    return i && Array.isArray(m) ? d = d.concat(m) : d.push(m), d;
+  }, []) : a ? [] : void 0;
+};
+C.prototype._getPreferredOutput = function(t) {
+  const e = this.currResultType;
+  switch (e) {
+    case "all": {
+      const r = Array.isArray(t.path) ? t.path : C.toPathArray(t.path);
+      return t.pointer = C.toPointer(r), t.path = typeof t.path == "string" ? t.path : C.toPathString(t.path), t;
+    }
+    case "value":
+    case "parent":
+    case "parentProperty":
+      return t[e];
+    case "path":
+      return C.toPathString(t[e]);
+    case "pointer":
+      return C.toPointer(t.path);
+    default:
+      throw new TypeError("Unknown result type");
+  }
+};
+C.prototype._handleCallback = function(t, e, r) {
+  if (e) {
+    const n = this._getPreferredOutput(t);
+    t.path = typeof t.path == "string" ? t.path : C.toPathString(t.path), e(n, r, t);
+  }
+};
+C.prototype._trace = function(t, e, r, n, s, o, i, a) {
+  let c;
+  if (!t.length)
+    return c = {
+      path: r,
+      value: e,
+      parent: n,
+      parentProperty: s,
+      hasArrExpr: i
+    }, this._handleCallback(c, o, "value"), c;
+  const u = t[0], d = t.slice(1), h = [];
+  function m(p) {
+    Array.isArray(p) ? p.forEach((b) => {
+      h.push(b);
+    }) : h.push(p);
+  }
+  if ((typeof u != "string" || a) && e && Object.hasOwn(e, u))
+    m(this._trace(d, e[u], ee(r, u), e, u, o, i));
+  else if (u === "*")
+    this._walk(e, (p) => {
+      m(this._trace(d, e[p], ee(r, p), e, p, o, !0, !0));
+    });
+  else if (u === "..")
+    m(this._trace(d, e, r, n, s, o, i)), this._walk(e, (p) => {
+      typeof e[p] == "object" && m(this._trace(t.slice(), e[p], ee(r, p), e, p, o, !0));
+    });
+  else {
+    if (u === "^")
+      return this._hasParentSelector = !0, {
+        path: r.slice(0, -1),
+        expr: d,
+        isParentSelector: !0
+      };
+    if (u === "~")
+      return c = {
+        path: ee(r, u),
+        value: s,
+        parent: n,
+        parentProperty: null
+      }, this._handleCallback(c, o, "property"), c;
+    if (u === "$")
+      m(this._trace(d, e, r, null, null, o, i));
+    else if (/^(-?\d*):(-?\d*):?(\d*)$/u.test(u))
+      m(this._slice(u, d, e, r, n, s, o));
+    else if (u.indexOf("?(") === 0) {
+      if (this.currEval === !1)
+        throw new Error("Eval [?(expr)] prevented in JSONPath expression.");
+      const p = u.replace(/^\?\((.*?)\)$/u, "$1"), b = /@.?([^?]*)[['](\??\(.*?\))(?!.\)\])[\]']/gu.exec(p);
+      b ? this._walk(e, (g) => {
+        const D = [b[2]], F = b[1] ? e[g][b[1]] : e[g];
+        this._trace(D, F, r, n, s, o, !0).length > 0 && m(this._trace(d, e[g], ee(r, g), e, g, o, !0));
+      }) : this._walk(e, (g) => {
+        this._eval(p, e[g], g, r, n, s) && m(this._trace(d, e[g], ee(r, g), e, g, o, !0));
+      });
+    } else if (u[0] === "(") {
+      if (this.currEval === !1)
+        throw new Error("Eval [(expr)] prevented in JSONPath expression.");
+      m(this._trace(we(this._eval(u, e, r.at(-1), r.slice(0, -1), n, s), d), e, r, n, s, o, i));
+    } else if (u[0] === "@") {
+      let p = !1;
+      const b = u.slice(1, -2);
+      switch (b) {
+        case "scalar":
+          (!e || !["object", "function"].includes(typeof e)) && (p = !0);
+          break;
+        case "boolean":
+        case "string":
+        case "undefined":
+        case "function":
+          typeof e === b && (p = !0);
+          break;
+        case "integer":
+          Number.isFinite(e) && !(e % 1) && (p = !0);
+          break;
+        case "number":
+          Number.isFinite(e) && (p = !0);
+          break;
+        case "nonFinite":
+          typeof e == "number" && !Number.isFinite(e) && (p = !0);
+          break;
+        case "object":
+          e && typeof e === b && (p = !0);
+          break;
+        case "array":
+          Array.isArray(e) && (p = !0);
+          break;
+        case "other":
+          p = this.currOtherTypeCallback(e, r, n, s);
+          break;
+        case "null":
+          e === null && (p = !0);
+          break;
+        /* c8 ignore next 2 */
+        default:
+          throw new TypeError("Unknown value type " + b);
+      }
+      if (p)
+        return c = {
+          path: r,
+          value: e,
+          parent: n,
+          parentProperty: s
+        }, this._handleCallback(c, o, "value"), c;
+    } else if (u[0] === "`" && e && Object.hasOwn(e, u.slice(1))) {
+      const p = u.slice(1);
+      m(this._trace(d, e[p], ee(r, p), e, p, o, i, !0));
+    } else if (u.includes(",")) {
+      const p = u.split(",");
+      for (const b of p)
+        m(this._trace(we(b, d), e, r, n, s, o, !0));
+    } else !a && e && Object.hasOwn(e, u) && m(this._trace(d, e[u], ee(r, u), e, u, o, i, !0));
+  }
+  if (this._hasParentSelector)
+    for (let p = 0; p < h.length; p++) {
+      const b = h[p];
+      if (b && b.isParentSelector) {
+        const g = this._trace(b.expr, e, b.path, n, s, o, i);
+        if (Array.isArray(g)) {
+          h[p] = g[0];
+          const D = g.length;
+          for (let F = 1; F < D; F++)
+            p++, h.splice(p, 0, g[F]);
+        } else
+          h[p] = g;
+      }
+    }
+  return h;
+};
+C.prototype._walk = function(t, e) {
+  if (Array.isArray(t)) {
+    const r = t.length;
+    for (let n = 0; n < r; n++)
+      e(n);
+  } else t && typeof t == "object" && Object.keys(t).forEach((r) => {
+    e(r);
+  });
+};
+C.prototype._slice = function(t, e, r, n, s, o, i) {
+  if (!Array.isArray(r))
+    return;
+  const a = r.length, c = t.split(":"), u = c[2] && Number.parseInt(c[2]) || 1;
+  let d = c[0] && Number.parseInt(c[0]) || 0, h = c[1] && Number.parseInt(c[1]) || a;
+  d = d < 0 ? Math.max(0, d + a) : Math.min(a, d), h = h < 0 ? Math.max(0, h + a) : Math.min(a, h);
+  const m = [];
+  for (let p = d; p < h; p += u)
+    this._trace(we(p, e), r, n, s, o, i, !0).forEach((g) => {
+      m.push(g);
+    });
+  return m;
+};
+C.prototype._eval = function(t, e, r, n, s, o) {
+  this.currSandbox._$_parentProperty = o, this.currSandbox._$_parent = s, this.currSandbox._$_property = r, this.currSandbox._$_root = this.json, this.currSandbox._$_v = e;
+  const i = t.includes("@path");
+  i && (this.currSandbox._$_path = C.toPathString(n.concat([r])));
+  const a = this.currEval + "Script:" + t;
+  if (!C.cache[a]) {
+    let c = t.replaceAll("@parentProperty", "_$_parentProperty").replaceAll("@parent", "_$_parent").replaceAll("@property", "_$_property").replaceAll("@root", "_$_root").replaceAll(/@([.\s)[])/gu, "_$_v$1");
+    if (i && (c = c.replaceAll("@path", "_$_path")), this.currEval === "safe" || this.currEval === !0 || this.currEval === void 0)
+      C.cache[a] = new this.safeVm.Script(c);
+    else if (this.currEval === "native")
+      C.cache[a] = new this.vm.Script(c);
+    else if (typeof this.currEval == "function" && this.currEval.prototype && Object.hasOwn(this.currEval.prototype, "runInNewContext")) {
+      const u = this.currEval;
+      C.cache[a] = new u(c);
+    } else if (typeof this.currEval == "function")
+      C.cache[a] = {
+        runInNewContext: (u) => this.currEval(c, u)
+      };
+    else
+      throw new TypeError(`Unknown "eval" property "${this.currEval}"`);
+  }
+  try {
+    return C.cache[a].runInNewContext(this.currSandbox);
+  } catch (c) {
+    if (this.ignoreEvalErrors)
+      return !1;
+    throw new Error("jsonPath: " + c.message + ": " + t);
+  }
+};
+C.cache = {};
+C.toPathString = function(t) {
+  const e = t, r = e.length;
+  let n = "$";
+  for (let s = 1; s < r; s++)
+    /^(~|\^|@.*?\(\))$/u.test(e[s]) || (n += /^[0-9*]+$/u.test(e[s]) ? "[" + e[s] + "]" : "['" + e[s] + "']");
+  return n;
+};
+C.toPointer = function(t) {
+  const e = t, r = e.length;
+  let n = "";
+  for (let s = 1; s < r; s++)
+    /^(~|\^|@.*?\(\))$/u.test(e[s]) || (n += "/" + e[s].toString().replaceAll("~", "~0").replaceAll("/", "~1"));
+  return n;
+};
+C.toPathArray = function(t) {
+  const {
+    cache: e
+  } = C;
+  if (e[t])
+    return e[t].concat();
+  const r = [], s = t.replaceAll(/@(?:null|boolean|number|string|integer|undefined|nonFinite|scalar|array|object|function|other)\(\)/gu, ";$&;").replaceAll(/[['](\??\(.*?\))[\]'](?!.\])/gu, function(o, i) {
+    return "[#" + (r.push(i) - 1) + "]";
+  }).replaceAll(/\[['"]([^'\]]*)['"]\]/gu, function(o, i) {
+    return "['" + i.replaceAll(".", "%@%").replaceAll("~", "%%@@%%") + "']";
+  }).replaceAll("~", ";~;").replaceAll(/['"]?\.['"]?(?![^[]*\])|\[['"]?/gu, ";").replaceAll("%@%", ".").replaceAll("%%@@%%", "~").replaceAll(/(?:;)?(\^+)(?:;)?/gu, function(o, i) {
+    return ";" + i.split("").join(";") + ";";
+  }).replaceAll(/;;;|;;/gu, ";..;").replaceAll(/;$|'?\]|'$/gu, "").split(";").map(function(o) {
+    const i = o.match(/#(\d+)/u);
+    return !i || !i[1] ? o : r[i[1]];
+  });
+  return e[t] = s, e[t].concat();
+};
+C.prototype.safeVm = {
+  Script: kr
+};
+const Rr = function(t, e, r) {
+  const n = t.length;
+  for (let s = 0; s < n; s++) {
+    const o = t[s];
+    r(o) && e.push(t.splice(s--, 1)[0]);
+  }
+};
+class Ir {
+  /**
+   * @param {string} expr Expression to evaluate
+   */
+  constructor(e) {
+    this.code = e;
+  }
+  /**
+   * @param {object} context Object whose items will be added
+   *   to evaluation
+   * @returns {EvaluatedResult} Result of evaluated code
+   */
+  runInNewContext(e) {
+    let r = this.code;
+    const n = Object.keys(e), s = [];
+    Rr(n, s, (u) => typeof e[u] == "function");
+    const o = n.map((u) => e[u]);
+    r = s.reduce((u, d) => {
+      let h = e[d].toString();
+      return /function/u.test(h) || (h = "function " + h), "var " + d + "=" + h + ";" + u;
+    }, "") + r, !/(['"])use strict\1/u.test(r) && !n.includes("arguments") && (r = "var arguments = undefined;" + r), r = r.replace(/;\s*$/u, "");
+    const a = r.lastIndexOf(";"), c = a !== -1 ? r.slice(0, a + 1) + " return " + r.slice(a + 1) : " return " + r;
+    return new Function(...n, c)(...o);
+  }
+}
+C.prototype.vm = {
+  Script: Ir
+};
+function Te(t, e, r) {
+  const n = e.replace(/^\$\.?/, "").split(/\.|\[|\]/).filter(Boolean);
+  let s = t;
+  for (let i = 0; i < n.length - 1; i++) {
+    const a = n[i], c = n[i + 1], u = /^\d+$/.test(c);
+    if (a === "__proto__" || a === "constructor" || a === "prototype")
+      throw new Error("Invalid path part: " + a);
+    if (a in s || (s[a] = u ? [] : {}), u) {
+      const d = parseInt(c, 10);
+      Array.isArray(s[a]) || (s[a] = []), s[a].length <= d && (s[a][d] = i === n.length - 2 ? r : {}), s = s[a][d], i++;
+    } else
+      s = s[a];
+  }
+  const o = n[n.length - 1];
+  if (o === "__proto__" || o === "constructor" || o === "prototype")
+    throw new Error("Invalid path part: " + o);
+  if (/^\d+$/.test(o)) {
+    const i = parseInt(o, 10);
+    Array.isArray(s) || (s = []), s[i] = r;
+  } else
+    s[o] = r;
+}
+const Xr = (t, e, r) => {
+  const n = {
+    type: e.type,
+    item: e.type === "single" ? {} : void 0,
+    list: e.type === "list" ? [] : void 0
+  }, s = (i, a) => {
+    let c = i;
+    return a.patchSource === "value" ? a.value ?? a.defaultValue ?? null : (a.patchSource === "child" && (c = r), (a.type === "single" ? C({ path: a.fromPath, json: c, resultType: "value" }) : C({ path: a.fromPath, json: c })) ?? a.defaultValue ?? null);
+  }, o = e.type === "single" ? C({ path: e.fromPath, json: t, resultType: "value" }) : C({ path: e.fromPath, json: t });
+  return e.type === "single" ? e.patches.forEach((i) => {
+    const a = s(o, i);
+    Te(n.item, i.toPath, a);
+  }) : e.type === "list" && (n.list = o.map((i) => {
+    const a = {};
+    return e.patches.forEach((c) => {
+      const u = s(i, c);
+      Te(a, c.toPath, u);
+    }), a;
+  })), n;
+};
+function Mr(t, e) {
+  const r = {};
+  return !t.events || !Object.keys(t.events).length || Object.entries(t.events).forEach(([n, s]) => {
+    s?.trim() && (r[n] = (...o) => {
+      try {
+        new Function("ctx", "craftNode", "args", s)(e, t, ...o);
+      } catch (i) {
+        console.error(`Event code execution failed with code:
+${s}
+
+Error:`, i);
+      }
+    });
+  }), r;
+}
+function Tr(t, e, r = "default") {
+  if (!t.slots || !t.slots[r]) return [];
+  const n = t.slots[r];
+  return e.type === "single" ? n.map((s) => ({
+    ...s,
+    uuid: `${s.uuid}-single`,
+    props: { ...s.props, ...e.item || {} }
+  })) : e.type === "list" && e.list ? n.flatMap(
+    (s) => e.list.map((o, i) => ({
+      ...s,
+      uuid: `${s.uuid}-data-${i}`,
+      props: { ...s.props, ...o || {} }
+    }))
+  ) : [];
+}
+function _e(t, e, r, n, s) {
+  if (!ze(t))
+    return null;
+  const o = e.resolveNode(t), i = o?.componentName || t.componentName, a = r?.[i] || i, c = {
+    ...o?.defaultProps || {},
+    ...t.props
+  }, u = s ? Mr(t, s) : {}, d = n?.[t.uuid];
+  let h;
+  return d?.type ? h = Tr(t, d, d.slotName || "default").map((p) => _e(p, e, r, n, s)).filter((p) => p !== null) : t.slots && (h = Object.values(t.slots).flat().map((m) => _e(m, e, r, n, s)).filter((m) => m !== null)), pt(a, { key: t.uuid, ...c, ...u }, h);
+}
+function zr(t, e) {
+  const r = new ye(e.resolverMap);
+  return t.map(
+    (n) => _e(
+      n,
+      r,
+      e.componentRegistry,
+      e.nodeDataMap,
+      e.eventsContext
+    )
+  ).filter((n) => n !== null);
+}
+const qr = {
+  CraftComponentSimpleText: {
+    componentName: "CraftComponentSimpleText",
+    eventsSchema: {
+      $el: "div",
+      children: [
+        {
+          $formkit: "textarea",
+          name: "click",
+          label: "onClick"
+        }
+      ]
+    },
+    propsSchema: [
+      {
+        $formkit: "select",
+        label: "Type",
+        name: "componentName",
+        options: [
+          "h1",
+          "h2",
+          "h3",
+          "h4",
+          "h5",
+          "h6",
+          "p",
+          "span",
+          "div",
+          "blockquote"
+        ]
+      },
+      {
+        $formkit: "textarea",
+        label: "Content",
+        name: "content"
+      },
+      {
+        $formkit: "text",
+        label: "Class",
+        name: "class"
+      }
+    ]
+  },
+  CraftCanvas: {
+    componentName: "CraftCanvas"
+  }
+}, Ur = (t) => {
+  for (const e in Ie)
+    t.component(e, Ie[e]);
+}, Wr = { install: Ur };
+export {
+  vt as CraftCanvas,
+  Et as CraftComponentSimpleText,
+  Ct as CraftEditor,
+  wt as CraftEditorBlueprint,
+  At as CraftEditorBlueprintsList,
+  $t as CraftEditorPanelBlueprints,
+  Rt as CraftEditorPanelForm,
+  Bt as CraftEditorPanelLayers,
+  Xt as CraftEditorPanelLayout,
+  qt as CraftEditorPanelNodeEventsSettings,
+  Zt as CraftEditorPanelNodeLayer,
+  er as CraftEditorPanelNodeSettings,
+  ir as CraftEditorPanelSettings,
+  cr as CraftFrame,
+  Qe as CraftIframe,
+  br as CraftNodeEditor,
+  ye as CraftNodeResolver,
+  ve as CraftNodeViewer,
+  Er as CraftStaticRenderer,
+  _t as Utils,
+  Wr as VCraft,
+  We as buildCraftNodeTree,
+  ie as craftNodeCanBeChildOf,
+  pe as craftNodeCanBeSiblingOf,
+  gt as craftNodeInCanvas,
+  qe as craftNodeIsAncestorOf,
+  q as craftNodeIsCanvas,
+  yt as craftNodeIsDraggable,
+  Vr as defaultBlueprints,
+  qr as defaultResolvers,
+  ze as isVisible,
+  Xr as mapData,
+  _e as renderCraftNodeToVNode,
+  zr as renderCraftNodesToVNodes,
+  te as resolveNodeName,
+  mt as useCraftNode,
+  j as useEditor,
+  Se as useIndicator,
+  xe as useResolveCraftNode
+};
+//# sourceMappingURL=v-craft.es.js.map