mechanica 1.0.0

package/dist/editor.js

@@ -0,0 +1,2671 @@
+import { watch, defineComponent, computed, inject, openBlock, createElementBlock, Fragment, renderList, createElementVNode, toDisplayString, getCurrentScope, onScopeDispose, toRef as toRef$1, readonly, customRef, ref, toValue, nextTick, getCurrentInstance, onMounted, createBlock, Teleport, createVNode, Transition, withCtx, unref, mergeProps, withModifiers, renderSlot, createCommentVNode, resolveDynamicComponent, normalizeClass, shallowRef, isRef, createTextVNode, reactive, shallowReactive, normalizeStyle, normalizeProps, guardReactiveProps, TransitionGroup, useSlots, createSlots, withDirectives, vModelText, vModelDynamic, createStaticVNode, mergeModels, useModel, resolveComponent, provide, createApp } from "vue";
+import { blocksList as blocksList$1 } from "virtual:builder-blocks";
+import { registerAlias, unfoldSchema } from "compact-json-schema";
+const findParent = (el, callback) => {
+  if (callback(el)) return el;
+  if (!el.parentElement) return null;
+  return findParent(el.parentElement, callback);
+};
+const clickOnIgnore = (target, ignoreEl) => {
+  if (!ignoreEl) return false;
+  return !!findParent(target, (el) => {
+    if (!Array.isArray(ignoreEl)) return el === ignoreEl.value;
+    for (const item of ignoreEl) {
+      if (item.value === el) return true;
+    }
+    return false;
+  });
+};
+const useMouseDownOutside = (condition, onMouseDown, ignoreEl) => {
+  const clickOutside = (e) => {
+    if (e.defaultPrevented) return;
+    if (clickOnIgnore(e.target, ignoreEl)) return;
+    onMouseDown();
+  };
+  watch(condition, (value) => {
+    setTimeout(() => {
+      if (value) {
+        document.addEventListener("mousedown", clickOutside);
+      } else {
+        document.removeEventListener("mousedown", clickOutside);
+      }
+    }, 50);
+  }, { flush: "post" });
+};
+const isTouchEvent = (e) => {
+  return "touches" in e;
+};
+function getPos(_e, relativeRect, type, touchIndex = -1) {
+  const e = isTouchEvent(_e) ? _e.touches[touchIndex < 0 ? _e.touches.length - 1 : touchIndex] : _e;
+  if (!e) return { x: 0, y: 0 };
+  if (relativeRect && type !== "absolute") {
+    if (type === "threejs") {
+      const _x = (e.clientX - relativeRect.left) / relativeRect.width * 2 - 1;
+      const _y = -(e.clientY - relativeRect.top) / relativeRect.height * 2 + 1;
+      return { x: _x, y: _y };
+    } else {
+      return { x: e.clientX - relativeRect.x, y: e.clientY - relativeRect.y };
+    }
+  } else {
+    return { x: e.clientX, y: e.clientY };
+  }
+}
+const getTouch = (e, touchId) => {
+  if (isTouchEvent(e) && touchId !== null) {
+    for (let touch of e.touches) {
+      if (touch.identifier === touchId) return touch;
+    }
+  }
+  return e;
+};
+function handleMove(e, { onStart, onMove, onEnd, relativeRect, type, prevent, threshold } = {}) {
+  const box = relativeRect ?? e.currentTarget.getBoundingClientRect();
+  const touchId = isTouchEvent(e) ? (e.changedTouches[0] ?? e.touches[e.touches.length - 1]).identifier : null;
+  const startPos = getPos(getTouch(e, touchId), box, type ?? "absolute");
+  let lastPos = startPos;
+  let moving = false;
+  const move = (e2) => {
+    const pos = getPos(getTouch(e2, touchId), box, type ?? "absolute");
+    if (moving === false && threshold && Math.abs(pos.x - startPos.x) < threshold) {
+      return;
+    }
+    if (moving === false && threshold) {
+      startPos.x = pos.x;
+      startPos.y = pos.y;
+      moving = true;
+    }
+    if (!e2.defaultPrevented && prevent !== false) {
+      e2.preventDefault();
+      e2.stopImmediatePropagation();
+    }
+    if (onMove) {
+      const deltaPos = { x: pos.x - lastPos.x, y: pos.y - lastPos.y };
+      onMove({ e: e2, pos, deltaPos, startPos });
+    }
+    lastPos = pos;
+  };
+  const end = (e2) => {
+    if (isTouchEvent(e2) && e2.touches.length > 0 && e2.changedTouches[0].identifier !== touchId) return;
+    if (!e2.defaultPrevented && prevent !== false) {
+      e2.preventDefault();
+      e2.stopImmediatePropagation();
+    }
+    dispose(e2);
+  };
+  const dispose = (e2) => {
+    document.removeEventListener("touchmove", move);
+    document.removeEventListener("mousemove", move);
+    document.removeEventListener("touchend", end);
+    document.removeEventListener("touchcancel", end);
+    document.removeEventListener("mouseup", end);
+    if (onEnd) {
+      const pos = getPos(getTouch(e2, touchId), box, type ?? "absolute");
+      if (pos.x === 0 && pos.y === 0) {
+        onEnd({ e: e2, pos: lastPos, startPos, deltaPos: { x: 0, y: 0 } });
+        return;
+      }
+      const deltaPos = { x: pos.x - lastPos.x, y: pos.y - lastPos.y };
+      onEnd({ e: e2, pos, startPos, deltaPos });
+    }
+  };
+  if (onStart) {
+    onStart({ e, pos: startPos, deltaPos: { x: 0, y: 0 }, startPos });
+  }
+  move(e);
+  if (isTouchEvent(e)) {
+    document.addEventListener("touchmove", move, { passive: prevent !== true });
+    document.addEventListener("touchend", end, { passive: prevent !== true });
+    document.addEventListener("touchcancel", end, { passive: prevent !== true });
+  } else {
+    document.addEventListener("mousemove", move);
+    document.addEventListener("mouseup", end);
+  }
+}
+const useDraggableItem = () => {
+  let clonedItem;
+  const drag = (e, options) => {
+    if (clonedItem) {
+      clonedItem.remove();
+      clonedItem = null;
+    }
+    const el = e.currentTarget;
+    const rect = el.getBoundingClientRect();
+    const offset = { left: rect.left - e.clientX, top: rect.top - e.clientY };
+    const width = el.clientWidth;
+    const onStart = () => {
+      var _a;
+      clonedItem = el.cloneNode(true);
+      clonedItem.setAttribute("style", "position: fixed; pointer-events: none;");
+      document.body.append(clonedItem);
+      (_a = options.onStart) == null ? void 0 : _a.call(options, clonedItem);
+    };
+    const threshold = options.threshold ?? 10;
+    handleMove(e, {
+      onMove({ e: e2, pos, startPos }) {
+        var _a;
+        if (!clonedItem) {
+          if (Math.abs(pos.x - startPos.x) > threshold || Math.abs(pos.y - startPos.y) > threshold) {
+            onStart();
+          }
+          return;
+        }
+        clonedItem.setAttribute(
+          "style",
+          `position: fixed; top: ${pos.y + offset.top}px; left: ${pos.x + offset.left}px; width: ${width}px; pointer-events: none;`
+        );
+        (_a = options.onMove) == null ? void 0 : _a.call(options, e2, clonedItem);
+      },
+      onEnd({ e: e2 }) {
+        var _a;
+        if (!clonedItem) return;
+        clonedItem.remove();
+        clonedItem = null;
+        (_a = options.onEnd) == null ? void 0 : _a.call(options, e2);
+      },
+      type: "absolute"
+    });
+  };
+  return drag;
+};
+const cloneDeep = (obj) => {
+  if (typeof obj !== "object" || obj === null) return obj;
+  if (Array.isArray(obj)) {
+    return [...obj.map(cloneDeep)];
+  }
+  return Object.fromEntries(Object.entries(obj).map(([key, value]) => [key, cloneDeep(value)]));
+};
+class MultiMap {
+  constructor() {
+    this._map = /* @__PURE__ */ new Map();
+  }
+  get size() {
+    return this._map.size;
+  }
+  add(key, value) {
+    const arr = this._map.get(key);
+    if (!arr) {
+      this._map.set(key, [value]);
+    } else {
+      arr.push(value);
+    }
+  }
+  remove(key, value) {
+    const arr = this._map.get(key);
+    if (!arr) return false;
+    const newArr = arr.filter((item) => item !== value);
+    if (newArr.length === arr.length) return false;
+    if (newArr.length === 0) {
+      this._map.delete(key);
+    } else {
+      this._map.set(key, newArr);
+    }
+    return true;
+  }
+  has(key) {
+    return this._map.has(key);
+  }
+  get(key) {
+    return this._map.get(key) || [];
+  }
+  forEach(key, callback) {
+    const arr = this._map.get(key);
+    if (!arr) return;
+    arr.forEach(callback);
+  }
+  clear() {
+    this._map.clear();
+  }
+}
+const listeners = new MultiMap();
+let hasEvent = false;
+const useKeyDownLayer = (key, watcher, callback) => {
+  const onKeyDown = (e) => {
+    if (!listeners.has(e.code)) return;
+    const _listeners = listeners.get(e.code);
+    e.preventDefault();
+    const callback2 = _listeners[_listeners.length - 1];
+    callback2(e);
+  };
+  watch(watcher, (value) => {
+    if (value) {
+      listeners.add(key, callback);
+    } else {
+      listeners.remove(key, callback);
+    }
+    if (listeners.size > 0 && !hasEvent) {
+      document.addEventListener("keydown", onKeyDown);
+      hasEvent = true;
+    }
+    if (listeners.size === 0) {
+      document.removeEventListener("keydown", onKeyDown);
+      hasEvent = false;
+    }
+  }, { immediate: true });
+};
+class BlockDropEvent extends Event {
+  constructor(block, content = null) {
+    super("blockdrop", { bubbles: true });
+    this.content = null;
+    this.block = block;
+    this.content = content;
+  }
+}
+const _hoisted_1$g = { class: "blocks-list" };
+const _hoisted_2$5 = { class: "page-editor-blocks__group" };
+const _hoisted_3$4 = { class: "title" };
+const _hoisted_4$4 = { class: "blocks-list__blocks" };
+const _hoisted_5$2 = ["onMousedown"];
+const _sfc_main$m = /* @__PURE__ */ defineComponent({
+  __name: "BlocksList",
+  props: {
+    blocks: {}
+  },
+  setup(__props) {
+    const props = __props;
+    const groupBlocks = computed(() => {
+      const groups = new MultiMap();
+      for (let block of props.blocks) {
+        if (block.hidden || block.isDev) continue;
+        groups.add(block.group ?? "default", block);
+      }
+      const output = [];
+      for (let [groupName, blocks] of groups._map) {
+        blocks.sort((a, b) => (a.order ?? 0) - (b.order ?? 0));
+        output.push({ name: groupName, blocks });
+      }
+      return output;
+    });
+    const groupNames = {
+      default: "Доступные блоки",
+      layout: "Макет"
+    };
+    const drag = useDraggableItem();
+    const dragMode = inject("dragMode");
+    const onItemMouseDown = (e, item) => {
+      drag(e, {
+        onStart(item2) {
+          item2.classList.add("drag");
+          document.body.classList.add("mousedrag");
+          dragMode.value = true;
+        },
+        onEnd(e2) {
+          var _a;
+          document.body.classList.remove("mousedrag");
+          (_a = e2.target) == null ? void 0 : _a.dispatchEvent(new BlockDropEvent(item));
+          dragMode.value = false;
+        }
+      });
+    };
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", _hoisted_1$g, [
+        (openBlock(true), createElementBlock(Fragment, null, renderList(groupBlocks.value, (group) => {
+          return openBlock(), createElementBlock("div", _hoisted_2$5, [
+            createElementVNode("div", _hoisted_3$4, toDisplayString(groupNames[group.name] ?? group.name), 1),
+            createElementVNode("div", _hoisted_4$4, [
+              (openBlock(true), createElementBlock(Fragment, null, renderList(group.blocks, (item) => {
+                return openBlock(), createElementBlock("button", {
+                  class: "blocks-list__block editor-component",
+                  key: item.id,
+                  onMousedown: ($event) => onItemMouseDown($event, item)
+                }, toDisplayString(item.name), 41, _hoisted_5$2);
+              }), 128))
+            ])
+          ]);
+        }), 256))
+      ]);
+    };
+  }
+});
+const defaultImageSrc = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAADwAAAA8CAMAAAANIilAAAAAUVBMVEUAAADy8vLy8vLy8vLy8vLv7+/v7+/x8fHz8/Py8vJtbW2fn5/h4eGvr6+wsLDq6uqoqKh+fn7Jycm4uLiOjo51dXWGhoaWlpbZ2dnAwMDY2NgSuPoLAAAACXRSTlMA38+/XyAQgH+A/hFhAAABBUlEQVRIx+3X3YqDMBCG4ala3XwxJv5E273/C90RlLAodBxPWup7IFF80BwYCRGVP7k5XFbQ3P1mVN3ujNkqdUmFUVdRpsc5mRNd+MLfhDu7LTxF2A/YbfQCbIHBbpqAIMBAb3ZyiP4lroF6I5frn4DrE9jBqXEPwCnxA2hZq3DdovUNawX2bPnOVff9ETwBD2NW7fgoxxbgZ626A+fEGGh4sOqIsWEtxlM6DZinz9oKcevT6YjIZtZC/Pvvwd3y/oc/DJemHyTYx7RkdEhjBwhWkpCWoQjYpYGHAuxH7DZ40dL7DHZb9/Z/jAtf+F1wrrcZVXpcUKnfGp3clHFFdpzmVUn0B/oSge0dVY8uAAAAAElFTkSuQmCC";
+const getDefaultValue = (schema) => {
+  if (schema.default) return schema.default;
+  if (schema.nullable) return null;
+  if (schema.type === "object" && schema.format === "image") {
+    return { src: defaultImageSrc, previewSrc: defaultImageSrc };
+  }
+  if (schema.type === "number" || schema.type === "integer") return 0;
+  if (schema.type === "object") return {};
+  if (schema.type === "array") return [];
+  if (schema.type === "boolean") return false;
+  return "";
+};
+const passDefaultValue = (state, schema) => {
+  if (!schema) return state;
+  if (schema.type === "object" && state) {
+    for (let key in schema.properties) {
+      if (!(key in state) && !schema.required.includes(key)) continue;
+      state[key] = passDefaultValue(state[key], schema.properties[key]);
+    }
+  }
+  return state ?? getDefaultValue(schema);
+};
+const walkTree = (blocks, callback) => {
+  for (let block of blocks) {
+    callback(block);
+    if (!block.children) continue;
+    if (Array.isArray(block.children)) {
+      walkTree(block.children, callback);
+    } else {
+      for (let value of Object.values(block.children)) {
+        walkTree(value, callback);
+      }
+    }
+  }
+};
+const walkSchema = (obj, schema, callback) => {
+  if (schema.type === "object") {
+    if (!obj) {
+      return;
+    }
+    for (let [key, value] of Object.entries(obj)) {
+      const childSchema = schema.properties[key];
+      if (!childSchema) continue;
+      const isRequired = schema.required.includes(key);
+      callback(value, childSchema, key, obj, isRequired);
+      if (childSchema.type === "array" || childSchema.type === "object") {
+        walkSchema(value, childSchema, callback);
+      }
+    }
+  }
+  if (schema.type === "array" && schema.items) {
+    for (let value of obj) {
+      callback(value, schema.items);
+      if (schema.items.type === "array" || schema.items.type === "object") {
+        walkSchema(value, schema.items, callback);
+      }
+    }
+  }
+};
+const findBlock = (blocks, callback) => {
+  for (let block of blocks) {
+    if (callback(block)) {
+      return block;
+    }
+    if (!block.children) continue;
+    if (Array.isArray(block.children)) {
+      const result = findBlock(block.children, callback);
+      if (result) return result;
+    } else {
+      for (let value of Object.values(block.children)) {
+        const result = findBlock(value, callback);
+        if (result) return result;
+      }
+    }
+  }
+  return null;
+};
+const hasSlots = (block) => {
+  return !!block.slots && Object.keys(block.slots).length > 0;
+};
+const hasMultipleSlots = (block) => {
+  if (!block.slots || Object.keys(block.slots).length === 0) return false;
+  return Object.keys(block.slots).length > 1 || Object.keys(block.slots)[0] !== "default";
+};
+const forEachChildren = (block, content, callback) => {
+  if (!hasSlots(block)) {
+    if (content.children) {
+      delete content.children;
+    }
+    return;
+  }
+  if (hasMultipleSlots(block)) {
+    if (!content.children) content.children = {};
+    if (Array.isArray(content.children)) content.children = { default: content.children };
+    for (let key in block.slots) {
+      if (!content.children[key]) content.children[key] = [];
+      callback(content.children[key]);
+    }
+  } else {
+    if (!content.children) content.children = [];
+    if (!Array.isArray(content.children)) content.children = content.children.default ?? [];
+    callback(content.children);
+  }
+};
+const deleteBlock = (blocks, target) => {
+  let isDeleted = false;
+  walkTree(blocks, (block) => {
+    if (!block.children) return;
+    if (Array.isArray(block.children)) {
+      if (deleteFromArray(block.children, target)) {
+        isDeleted = true;
+      }
+    } else {
+      for (let children of Object.values(block.children)) {
+        if (deleteFromArray(children, target)) {
+          isDeleted = true;
+        }
+      }
+    }
+  });
+  if (!isDeleted) {
+    deleteFromArray(blocks, target);
+  }
+};
+const createContentBlockChild = (blocksMap2, contentBlock, parent, index = -1) => {
+  const parentBlock = blocksMap2.get(parent.blockId);
+  if (!parentBlock.slots) return;
+  if (Object.keys(parentBlock.slots).length === 1 && Object.keys(parentBlock.slots)[0] === "default") {
+    if (!parent.children) parent.children = [];
+    if (!Array.isArray(parent.children)) parent.children = parent.children.default ?? [];
+    if (index < 0) {
+      parent.children.push(contentBlock);
+    } else {
+      parent.children.splice(index, 0, contentBlock);
+    }
+  } else {
+    if (!parent.children || Array.isArray(parent.children)) parent.children = {};
+    if (index < 0) {
+      const key = "default" in parentBlock.slots ? "default" : Object.keys(parentBlock.slots)[0];
+      if (!parent.children[key]) parent.children[key] = [];
+      parent.children[key].push(contentBlock);
+    } else {
+      let startIndex = 0;
+      for (let children of Object.values(parent.children)) {
+        if (index - startIndex <= children.length) {
+          children.splice(index - startIndex, 0, contentBlock);
+        }
+        startIndex += children.length;
+      }
+    }
+  }
+};
+const getBlockIndex = (parent, target) => {
+  if (!parent.children) return -1;
+  if (Array.isArray(parent.children)) {
+    return parent.children.indexOf(target);
+  } else {
+    let startIndex = 0;
+    for (let children of Object.values(parent.children)) {
+      const index = children.indexOf(target);
+      if (index >= 0) {
+        return startIndex + index;
+      }
+      startIndex += children.length;
+    }
+    return -1;
+  }
+};
+const createContentBlock = (block) => {
+  const id = uid();
+  return {
+    id,
+    blockId: block.id,
+    data: {
+      ...passDefaultValue({}, block.props),
+      "data-block-id": id
+    }
+  };
+};
+const deleteFromArray = (arr, item) => {
+  const index = arr.indexOf(item);
+  if (index < 0) return false;
+  arr.splice(index, 1);
+  return true;
+};
+const uid = () => {
+  return Math.trunc(Math.random() * 1e5).toString(16);
+};
+function tryOnScopeDispose(fn) {
+  if (getCurrentScope()) {
+    onScopeDispose(fn);
+    return true;
+  }
+  return false;
+}
+function createEventHook() {
+  const fns = /* @__PURE__ */ new Set();
+  const off = (fn) => {
+    fns.delete(fn);
+  };
+  const clear = () => {
+    fns.clear();
+  };
+  const on = (fn) => {
+    fns.add(fn);
+    const offFn = () => off(fn);
+    tryOnScopeDispose(offFn);
+    return {
+      off: offFn
+    };
+  };
+  const trigger = (...args) => {
+    return Promise.all(Array.from(fns).map((fn) => fn(...args)));
+  };
+  return {
+    on,
+    off,
+    trigger,
+    clear
+  };
+}
+const isClient = typeof window !== "undefined" && typeof document !== "undefined";
+typeof WorkerGlobalScope !== "undefined" && globalThis instanceof WorkerGlobalScope;
+const isDef = (val) => typeof val !== "undefined";
+const toString = Object.prototype.toString;
+const isObject = (val) => toString.call(val) === "[object Object]";
+const noop = () => {
+};
+const hasOwn = (val, key) => Object.prototype.hasOwnProperty.call(val, key);
+function createFilterWrapper(filter, fn) {
+  function wrapper(...args) {
+    return new Promise((resolve, reject) => {
+      Promise.resolve(filter(() => fn.apply(this, args), { fn, thisArg: this, args })).then(resolve).catch(reject);
+    });
+  }
+  return wrapper;
+}
+const bypassFilter = (invoke) => {
+  return invoke();
+};
+function debounceFilter(ms, options = {}) {
+  let timer;
+  let maxTimer;
+  let lastRejector = noop;
+  const _clearTimeout = (timer2) => {
+    clearTimeout(timer2);
+    lastRejector();
+    lastRejector = noop;
+  };
+  const filter = (invoke) => {
+    const duration = toValue(ms);
+    const maxDuration = toValue(options.maxWait);
+    if (timer)
+      _clearTimeout(timer);
+    if (duration <= 0 || maxDuration !== void 0 && maxDuration <= 0) {
+      if (maxTimer) {
+        _clearTimeout(maxTimer);
+        maxTimer = null;
+      }
+      return Promise.resolve(invoke());
+    }
+    return new Promise((resolve, reject) => {
+      lastRejector = options.rejectOnCancel ? reject : resolve;
+      if (maxDuration && !maxTimer) {
+        maxTimer = setTimeout(() => {
+          if (timer)
+            _clearTimeout(timer);
+          maxTimer = null;
+          resolve(invoke());
+        }, maxDuration);
+      }
+      timer = setTimeout(() => {
+        if (maxTimer)
+          _clearTimeout(maxTimer);
+        maxTimer = null;
+        resolve(invoke());
+      }, duration);
+    });
+  };
+  return filter;
+}
+function toArray(value) {
+  return Array.isArray(value) ? value : [value];
+}
+function toRef(...args) {
+  if (args.length !== 1)
+    return toRef$1(...args);
+  const r = args[0];
+  return typeof r === "function" ? readonly(customRef(() => ({ get: r, set: noop }))) : ref(r);
+}
+function watchWithFilter(source, cb, options = {}) {
+  const {
+    eventFilter = bypassFilter,
+    ...watchOptions
+  } = options;
+  return watch(
+    source,
+    createFilterWrapper(
+      eventFilter,
+      cb
+    ),
+    watchOptions
+  );
+}
+function watchDebounced(source, cb, options = {}) {
+  const {
+    debounce = 0,
+    maxWait = void 0,
+    ...watchOptions
+  } = options;
+  return watchWithFilter(
+    source,
+    cb,
+    {
+      ...watchOptions,
+      eventFilter: debounceFilter(debounce, { maxWait })
+    }
+  );
+}
+const defaultWindow = isClient ? window : void 0;
+const defaultDocument = isClient ? window.document : void 0;
+function unrefElement(elRef) {
+  var _a;
+  const plain = toValue(elRef);
+  return (_a = plain == null ? void 0 : plain.$el) != null ? _a : plain;
+}
+function useEventListener(...args) {
+  let target;
+  let events;
+  let listeners2;
+  let options;
+  if (typeof args[0] === "string" || Array.isArray(args[0])) {
+    [events, listeners2, options] = args;
+    target = defaultWindow;
+  } else {
+    [target, events, listeners2, options] = args;
+  }
+  if (!target)
+    return noop;
+  events = toArray(events);
+  listeners2 = toArray(listeners2);
+  const cleanups = [];
+  const cleanup = () => {
+    cleanups.forEach((fn) => fn());
+    cleanups.length = 0;
+  };
+  const register = (el, event, listener, options2) => {
+    el.addEventListener(event, listener, options2);
+    return () => el.removeEventListener(event, listener, options2);
+  };
+  const stopWatch = watch(
+    () => [unrefElement(target), toValue(options)],
+    ([el, options2]) => {
+      cleanup();
+      if (!el)
+        return;
+      const optionsClone = isObject(options2) ? { ...options2 } : options2;
+      cleanups.push(
+        ...events.flatMap((event) => {
+          return listeners2.map((listener) => register(el, event, listener, optionsClone));
+        })
+      );
+    },
+    { immediate: true, flush: "post" }
+  );
+  const stop = () => {
+    stopWatch();
+    cleanup();
+  };
+  tryOnScopeDispose(stop);
+  return stop;
+}
+function useMounted() {
+  const isMounted = ref(false);
+  const instance = getCurrentInstance();
+  if (instance) {
+    onMounted(() => {
+      isMounted.value = true;
+    }, instance);
+  }
+  return isMounted;
+}
+function useSupported(callback) {
+  const isMounted = useMounted();
+  return computed(() => {
+    isMounted.value;
+    return Boolean(callback());
+  });
+}
+function cloneFnJSON(source) {
+  return JSON.parse(JSON.stringify(source));
+}
+function useResizeObserver(target, callback, options = {}) {
+  const { window: window2 = defaultWindow, ...observerOptions } = options;
+  let observer;
+  const isSupported = useSupported(() => window2 && "ResizeObserver" in window2);
+  const cleanup = () => {
+    if (observer) {
+      observer.disconnect();
+      observer = void 0;
+    }
+  };
+  const targets = computed(() => {
+    const _targets = toValue(target);
+    return Array.isArray(_targets) ? _targets.map((el) => unrefElement(el)) : [unrefElement(_targets)];
+  });
+  const stopWatch = watch(
+    targets,
+    (els) => {
+      cleanup();
+      if (isSupported.value && window2) {
+        observer = new ResizeObserver(callback);
+        for (const _el of els) {
+          if (_el)
+            observer.observe(_el, observerOptions);
+        }
+      }
+    },
+    { immediate: true, flush: "post" }
+  );
+  const stop = () => {
+    cleanup();
+    stopWatch();
+  };
+  tryOnScopeDispose(stop);
+  return {
+    isSupported,
+    stop
+  };
+}
+const DEFAULT_OPTIONS = {
+  multiple: true,
+  accept: "*",
+  reset: false,
+  directory: false
+};
+function useFileDialog(options = {}) {
+  const {
+    document: document2 = defaultDocument
+  } = options;
+  const files = ref(null);
+  const { on: onChange, trigger: changeTrigger } = createEventHook();
+  const { on: onCancel, trigger: cancelTrigger } = createEventHook();
+  let input;
+  if (document2) {
+    input = document2.createElement("input");
+    input.type = "file";
+    input.onchange = (event) => {
+      const result = event.target;
+      files.value = result.files;
+      changeTrigger(files.value);
+    };
+    input.oncancel = () => {
+      cancelTrigger();
+    };
+  }
+  const reset = () => {
+    files.value = null;
+    if (input && input.value) {
+      input.value = "";
+      changeTrigger(null);
+    }
+  };
+  const open = (localOptions) => {
+    if (!input)
+      return;
+    const _options = {
+      ...DEFAULT_OPTIONS,
+      ...options,
+      ...localOptions
+    };
+    input.multiple = _options.multiple;
+    input.accept = _options.accept;
+    input.webkitdirectory = _options.directory;
+    if (hasOwn(_options, "capture"))
+      input.capture = _options.capture;
+    if (_options.reset)
+      reset();
+    input.click();
+  };
+  return {
+    files: readonly(files),
+    open,
+    reset,
+    onCancel,
+    onChange
+  };
+}
+function useTextareaAutosize(options) {
+  var _a, _b;
+  const textarea = toRef(options == null ? void 0 : options.element);
+  const input = toRef((_a = options == null ? void 0 : options.input) != null ? _a : "");
+  const styleProp = (_b = options == null ? void 0 : options.styleProp) != null ? _b : "height";
+  const textareaScrollHeight = ref(1);
+  const textareaOldWidth = ref(0);
+  function triggerResize() {
+    var _a2;
+    if (!textarea.value)
+      return;
+    let height = "";
+    textarea.value.style[styleProp] = "1px";
+    textareaScrollHeight.value = (_a2 = textarea.value) == null ? void 0 : _a2.scrollHeight;
+    const _styleTarget = toValue(options == null ? void 0 : options.styleTarget);
+    if (_styleTarget)
+      _styleTarget.style[styleProp] = `${textareaScrollHeight.value}px`;
+    else
+      height = `${textareaScrollHeight.value}px`;
+    textarea.value.style[styleProp] = height;
+  }
+  watch([input, textarea], () => nextTick(triggerResize), { immediate: true });
+  watch(textareaScrollHeight, () => {
+    var _a2;
+    return (_a2 = options == null ? void 0 : options.onResize) == null ? void 0 : _a2.call(options);
+  });
+  useResizeObserver(textarea, ([{ contentRect }]) => {
+    if (textareaOldWidth.value === contentRect.width)
+      return;
+    textareaOldWidth.value = contentRect.width;
+    triggerResize();
+  });
+  if (options == null ? void 0 : options.watch)
+    watch(options.watch, triggerResize, { immediate: true, deep: true });
+  return {
+    textarea,
+    input,
+    triggerResize
+  };
+}
+function useVModel(props, key, emit, options = {}) {
+  var _a, _b, _c;
+  const {
+    clone = false,
+    passive = false,
+    eventName,
+    deep = false,
+    defaultValue,
+    shouldEmit
+  } = options;
+  const vm = getCurrentInstance();
+  const _emit = emit || (vm == null ? void 0 : vm.emit) || ((_a = vm == null ? void 0 : vm.$emit) == null ? void 0 : _a.bind(vm)) || ((_c = (_b = vm == null ? void 0 : vm.proxy) == null ? void 0 : _b.$emit) == null ? void 0 : _c.bind(vm == null ? void 0 : vm.proxy));
+  let event = eventName;
+  if (!key) {
+    key = "modelValue";
+  }
+  event = event || `update:${key.toString()}`;
+  const cloneFn = (val) => !clone ? val : typeof clone === "function" ? clone(val) : cloneFnJSON(val);
+  const getValue = () => isDef(props[key]) ? cloneFn(props[key]) : defaultValue;
+  const triggerEmit = (value) => {
+    if (shouldEmit) {
+      if (shouldEmit(value))
+        _emit(event, value);
+    } else {
+      _emit(event, value);
+    }
+  };
+  if (passive) {
+    const initialValue = getValue();
+    const proxy = ref(initialValue);
+    let isUpdating = false;
+    watch(
+      () => props[key],
+      (v) => {
+        if (!isUpdating) {
+          isUpdating = true;
+          proxy.value = cloneFn(v);
+          nextTick(() => isUpdating = false);
+        }
+      }
+    );
+    watch(
+      proxy,
+      (v) => {
+        if (!isUpdating && (v !== props[key] || deep))
+          triggerEmit(v);
+      },
+      { deep }
+    );
+    return proxy;
+  } else {
+    return computed({
+      get() {
+        return getValue();
+      },
+      set(value) {
+        triggerEmit(value);
+      }
+    });
+  }
+}
+const margin = 8;
+const _sfc_main$l = /* @__PURE__ */ defineComponent({
+  ...{
+    inheritAttrs: false
+  },
+  __name: "VPopover",
+  props: {
+    open: { type: Boolean },
+    element: {},
+    placement: {},
+    offset: {},
+    fitAnchor: { type: Boolean },
+    class: {},
+    anchorPosition: {}
+  },
+  emits: ["update:open"],
+  setup(__props, { emit: __emit }) {
+    const props = __props;
+    const emit = __emit;
+    const popoverRef = ref();
+    const position = ref({ top: 0, left: 0 });
+    const origin = ref("center");
+    const open = useVModel(props, "open", emit, { passive: true });
+    const activatorElement = ref();
+    const clamp = (value, min, max) => {
+      if (value < min) return min;
+      if (value > max) return max;
+      return value;
+    };
+    const calcPrimary = (pos, start, end, size, min, max) => {
+      const fitStart = start - size >= min;
+      const fitEnd = end + size <= max;
+      if ((!fitEnd || pos === "start") && fitStart) return start - size;
+      if ((!fitStart || pos === "end") && fitEnd) return end;
+      return pos === "start" ? min : max - size;
+    };
+    const calcSub = (pos, start, end, size, min, max) => {
+      if (pos === "start") return clamp(start, min, max - size);
+      if (pos === "end") return clamp(end - size, min, max - size);
+      return clamp((start + end) / 2 - size / 2, min, max - size);
+    };
+    const calcOrigin = (start, end, point) => {
+      return clamp(Math.round((point - start) / (end - start) * 100), 0, 100) + "%";
+    };
+    const getRect = () => {
+      if (props.anchorPosition) {
+        return {
+          top: props.anchorPosition.y,
+          bottom: props.anchorPosition.y,
+          left: props.anchorPosition.x,
+          right: props.anchorPosition.x,
+          width: 0,
+          height: 0
+        };
+      }
+      const element = props.element ?? activatorElement.value;
+      if (!element) return null;
+      return element.getBoundingClientRect();
+    };
+    const isHorizontal = computed(() => props.placement.startsWith("left") || props.placement.startsWith("right"));
+    const calcPosition = () => {
+      if (!popoverRef.value) return;
+      const rect = getRect();
+      if (!rect) return;
+      const placement = props.placement.split("-");
+      const offset = props.offset ?? 0;
+      const width = popoverRef.value.clientWidth;
+      const height = popoverRef.value.clientHeight;
+      if (placement[0] === "top" || placement[0] === "bottom") {
+        const top = calcPrimary(placement[0] === "top" ? "start" : "end", rect.top - offset, rect.bottom + offset, height, margin, window.innerHeight - margin);
+        if (props.fitAnchor) {
+          position.value = {
+            top,
+            left: calcSub("start", rect.left, rect.right, rect.width, margin, window.innerWidth - margin),
+            width: rect.width
+          };
+        } else {
+          position.value = { top, left: calcSub(placement[1], rect.left, rect.right, width, margin, window.innerWidth - margin) };
+        }
+      } else {
+        const left = calcPrimary(placement[0] === "left" ? "start" : "end", rect.left - offset, rect.right + offset, width, margin, window.innerWidth - margin);
+        if (props.fitAnchor) {
+          position.value = {
+            left,
+            top: calcSub("start", rect.top, rect.bottom, rect.height, margin, window.innerHeight - margin),
+            height: rect.height
+          };
+        } else {
+          position.value = { left, top: calcSub(placement[1], rect.top, rect.bottom, height, margin, window.innerHeight - margin) };
+        }
+      }
+      origin.value = calcOrigin(position.value.left, position.value.left + width, rect.left + rect.width / 2) + calcOrigin(position.value.top, position.value.top + height, rect.top + rect.height / 2);
+    };
+    watch([() => props.element, () => props.anchorPosition], () => {
+      calcPosition();
+    });
+    useResizeObserver(popoverRef, calcPosition);
+    useEventListener(window, "resize", calcPosition);
+    const close = () => {
+      open.value = false;
+    };
+    const closeDelayed = () => {
+      setTimeout(close, 0);
+    };
+    useKeyDownLayer("Escape", open, close);
+    useMouseDownOutside(open, closeDelayed, popoverRef);
+    watch(open, (open2) => {
+      if (!props.element) return;
+      if (open2) {
+        props.element.classList.add("popoverHover");
+      } else {
+        props.element.classList.remove("popoverHover");
+      }
+    });
+    const activatorProps = {
+      onMousedown: (e) => {
+        open.value = !open.value;
+        if (open.value) {
+          activatorElement.value = e.currentTarget;
+        }
+      },
+      onTouchstart: (e) => {
+        open.value = !open.value;
+        if (open.value) {
+          activatorElement.value = e.currentTarget;
+        }
+      }
+    };
+    const style = computed(() => {
+      return {
+        left: position.value.left + "px",
+        top: position.value.top + "px",
+        width: position.value.width ? position.value.width + "px" : void 0,
+        height: position.value.height ? position.value.height + "px" : void 0,
+        transformOrigin: origin.value
+      };
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock(Fragment, null, [
+        (openBlock(), createBlock(Teleport, { to: "body" }, [
+          createVNode(Transition, null, {
+            default: withCtx(() => [
+              unref(open) ? (openBlock(), createElementBlock("div", mergeProps({ key: 0 }, _ctx.$attrs, {
+                class: ["v-popover editor-component", [isHorizontal.value ? "horizontal" : "vertical", props.fitAnchor && "fit-anchor", props.class]],
+                style: style.value,
+                ref_key: "popoverRef",
+                ref: popoverRef,
+                onMousedown: _cache[0] || (_cache[0] = withModifiers(() => {
+                }, ["stop"]))
+              }), [
+                renderSlot(_ctx.$slots, "default")
+              ], 16)) : createCommentVNode("", true)
+            ]),
+            _: 3
+          })
+        ])),
+        renderSlot(_ctx.$slots, "activator", { props: activatorProps })
+      ], 64);
+    };
+  }
+});
+const _sfc_main$k = /* @__PURE__ */ defineComponent({
+  __name: "VButton",
+  props: {
+    component: {},
+    disabled: { type: Boolean },
+    flat: { type: Boolean },
+    outline: { type: Boolean },
+    large: { type: Boolean }
+  },
+  setup(__props) {
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(resolveDynamicComponent(_ctx.component ?? "button"), {
+        class: normalizeClass(["v-button", { disabled: _ctx.disabled, flat: _ctx.flat, outline: _ctx.outline, large: _ctx.large }])
+      }, {
+        default: withCtx(() => [
+          renderSlot(_ctx.$slots, "default")
+        ]),
+        _: 3
+      }, 8, ["class"]);
+    };
+  }
+});
+const useContextMenu = (creator) => {
+  let target = null;
+  const props = reactive({
+    items: [],
+    open: false,
+    anchorPosition: { x: 0, y: 0 },
+    "onUpdate:open": (value) => {
+      if (value === false && target !== null) {
+        target.removeAttribute("data-popover-target");
+        target = null;
+      }
+      props.open = value;
+    }
+  });
+  const open = (e, ...args) => {
+    e.preventDefault();
+    props.items = creator(...args);
+    props.anchorPosition = { x: e.clientX, y: e.clientY };
+    props.open = true;
+    if (target !== null) {
+      target.removeAttribute("data-popover-target");
+      target = null;
+    }
+    target = e.currentTarget;
+    target.setAttribute("data-popover-target", "true");
+  };
+  return {
+    props,
+    open
+  };
+};
+const _sfc_main$j = /* @__PURE__ */ defineComponent({
+  __name: "VContextMenu",
+  props: {
+    open: { type: Boolean },
+    placement: {},
+    anchorPosition: {},
+    offset: {},
+    items: { type: [Array, Function] }
+  },
+  emits: ["update:open"],
+  setup(__props, { emit: __emit }) {
+    const props = __props;
+    const activatorElement = ref();
+    const emit = __emit;
+    const open = useVModel(props, "open", emit, { passive: true });
+    const items = shallowRef([]);
+    watch(open, (open2) => {
+      if (!open2) return;
+      const _items = typeof props.items === "function" ? props.items() : props.items;
+      items.value = _items.filter((item) => !!item);
+    });
+    const activatorProps = {
+      onClick: (e) => {
+        open.value = true;
+        activatorElement.value = e.currentTarget;
+      }
+    };
+    const onItemClick = (item) => {
+      var _a, _b;
+      if (item.onClick) {
+        item.onClick();
+        open.value = false;
+      }
+      if (((_a = item.props) == null ? void 0 : _a.to) || ((_b = item.props) == null ? void 0 : _b.href)) {
+        open.value = false;
+      }
+    };
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock(Fragment, null, [
+        renderSlot(_ctx.$slots, "activator", { props: activatorProps }),
+        createVNode(_sfc_main$l, {
+          open: unref(open),
+          "onUpdate:open": _cache[0] || (_cache[0] = ($event) => isRef(open) ? open.value = $event : null),
+          element: activatorElement.value,
+          anchorPosition: props.anchorPosition,
+          placement: props.placement ?? "bottom-start",
+          offset: _ctx.offset,
+          class: "v-context-menu"
+        }, {
+          default: withCtx(() => [
+            (openBlock(true), createElementBlock(Fragment, null, renderList(items.value, (item) => {
+              return openBlock(), createBlock(_sfc_main$k, mergeProps({ ref_for: true }, item.props, {
+                class: "v-context-menu__item",
+                onClick: ($event) => onItemClick(item)
+              }), {
+                default: withCtx(() => [
+                  createTextVNode(toDisplayString(item.title), 1)
+                ]),
+                _: 2
+              }, 1040, ["onClick"]);
+            }), 256))
+          ]),
+          _: 1
+        }, 8, ["open", "element", "anchorPosition", "placement", "offset"])
+      ], 64);
+    };
+  }
+});
+const _hoisted_1$f = ["onBlockdrop", "onMousedown", "onMouseenter", "onClick", "onContextmenu"];
+const _hoisted_2$4 = ["onBlockdrop"];
+const _sfc_main$i = /* @__PURE__ */ defineComponent({
+  __name: "ContentHierarchy",
+  props: {
+    contentBlocks: {},
+    blocksMap: {},
+    hoverBlockId: {},
+    activeBlockId: {}
+  },
+  emits: ["update:hoverBlockId", "update:activeBlockId"],
+  setup(__props, { emit: __emit }) {
+    const props = __props;
+    const emit = __emit;
+    const flatBlocks = computed(() => {
+      const arr = [];
+      const collectBlocks = (items, intent = 0, parent = null) => {
+        for (let i = 0; i < items.length; i++) {
+          const data = items[i];
+          const block = props.blocksMap.get(data.blockId);
+          if (!block) {
+            arr.push({
+              content: data,
+              key: data.id,
+              intent,
+              hasSlots: false,
+              hasMultipleSlots: false,
+              block: {},
+              parent
+            });
+            continue;
+          }
+          arr.push({
+            content: data,
+            key: data.id,
+            intent,
+            hasSlots: hasSlots(block),
+            hasMultipleSlots: hasMultipleSlots(block),
+            block,
+            parent
+          });
+          forEachChildren(block, data, (blocks) => {
+            collectBlocks(blocks, intent + 1, data);
+          });
+        }
+      };
+      collectBlocks(props.contentBlocks);
+      return arr;
+    });
+    const drag = useDraggableItem();
+    const dragMode = inject("dragMode");
+    const onItemMouseDown = (e, item) => {
+      if (e.button !== 0) return;
+      const target = e.currentTarget;
+      drag(e, {
+        onStart(item2) {
+          target.setAttribute("data-source-drag", "");
+          item2.classList.add("drag");
+          document.body.classList.add("mousedrag");
+          dragMode.value = true;
+        },
+        onEnd(e2) {
+          var _a;
+          document.body.classList.remove("mousedrag");
+          target.removeAttribute("data-source-drag");
+          if (e2.target !== target) {
+            (_a = e2.target) == null ? void 0 : _a.dispatchEvent(new BlockDropEvent(item.block, item.content));
+          }
+          dragMode.value = false;
+        }
+      });
+    };
+    const containerRef = ref();
+    const places = shallowReactive([]);
+    watch(dragMode, (dragMode2) => {
+      if (!dragMode2 || !containerRef.value) {
+        places.length = 0;
+        return;
+      }
+      const containerRect = containerRef.value.getBoundingClientRect();
+      places.length = 0;
+      const children = Array.from(containerRef.value.children).filter((child) => child.classList.contains("page-editor-hierarchy__item"));
+      let lastRectHeight = 0;
+      let lastRectBottom = containerRect.top;
+      for (let i = 0; i < children.length + 1; i++) {
+        const child = children[i];
+        const rect = i === children.length ? { top: lastRectBottom, height: containerRect.bottom - lastRectBottom, bottom: 0 } : child.getBoundingClientRect();
+        let top = lastRectHeight * 0.2;
+        let bottom = rect.height * 0.2;
+        if (i > 0 && !flatBlocks.value[i - 1].hasSlots) {
+          top = lastRectHeight * 0.5;
+        }
+        if (i === children.length) {
+          bottom = rect.height;
+        } else if (!flatBlocks.value[i].hasSlots) {
+          bottom = rect.height * 0.5;
+        }
+        places.push({
+          index: i,
+          style: {
+            top: rect.top - containerRect.top + containerRef.value.scrollTop - top + "px",
+            paddingTop: top - 1 + "px",
+            height: top + bottom + "px"
+          }
+        });
+        lastRectHeight = rect.height;
+        lastRectBottom = rect.bottom;
+      }
+    });
+    const onItemBlockDrop = (e, item) => {
+      if (e.content) {
+        deleteBlock(props.contentBlocks, e.content);
+      }
+      if (item.hasSlots) {
+        const contentBlock = e.content ?? { id: uid(), blockId: e.block.id, data: {} };
+        createContentBlockChild(props.blocksMap, contentBlock, item.content, -1);
+      }
+    };
+    const onPlaceBlockDrop = (e, _index, dublicate = false) => {
+      e.stopPropagation();
+      let index = _index;
+      let content = e.content;
+      if (content && !dublicate) {
+        const sourceIndex = flatBlocks.value.findIndex((item) => item.content === content);
+        if (sourceIndex === index || sourceIndex === index - 1) return;
+        if (index > sourceIndex && sourceIndex !== -1) index--;
+        deleteBlock(props.contentBlocks, content);
+      }
+      if (content && dublicate) {
+        content = cloneDeep(content);
+        content.id = uid();
+        content.data["data-block-id"] = content.id;
+        forEachChildren(e.block, content, (contents) => {
+          for (let content2 of contents) {
+            content2.id = uid();
+          }
+        });
+      }
+      const contentBlock = content ?? createContentBlock(e.block);
+      if (index >= flatBlocks.value.length) {
+        props.contentBlocks.push(contentBlock);
+      } else {
+        const blockEntry = flatBlocks.value[index];
+        if (blockEntry.parent === null) {
+          const index2 = props.contentBlocks.indexOf(blockEntry.content);
+          props.contentBlocks.splice(index2, 0, contentBlock);
+        } else {
+          const index2 = getBlockIndex(blockEntry.parent, blockEntry.content);
+          createContentBlockChild(props.blocksMap, contentBlock, blockEntry.parent, index2);
+        }
+      }
+    };
+    const contextMenu = useContextMenu((content) => [
+      content !== null && { title: "Дублировать блок", onClick() {
+        const index = flatBlocks.value.findIndex((item) => item.content === content);
+        const block = props.blocksMap.get(content.blockId);
+        onPlaceBlockDrop(new BlockDropEvent(block, content), index, true);
+      } },
+      content !== null && { title: "Копировать блок", async onClick() {
+        const blob = new Blob([JSON.stringify(content)], { type: "text/plain" });
+        await navigator.clipboard.write([
+          new ClipboardItem({ "text/plain": blob })
+        ]);
+      } },
+      {
+        title: "Вставить блок",
+        onClick: () => placeBlockFromClipboard(content)
+      },
+      content !== null && {
+        title: "Удалить блок",
+        onClick: () => deleteBlock(props.contentBlocks, content)
+      }
+    ]);
+    const placeBlockFromClipboard = async (content) => {
+      const resp = await navigator.clipboard.read();
+      if (!resp[0].types.includes("text/plain")) return;
+      const entry = await resp[0].getType("text/plain");
+      const text = await entry.text();
+      if (!text.startsWith("{")) return;
+      try {
+        const contentData = JSON.parse(text);
+        contentData.id = uid();
+        const block = props.blocksMap.get(contentData.blockId);
+        if (!block) return;
+        if (content !== null) {
+          const index = flatBlocks.value.findIndex((item) => item.content === content);
+          if (flatBlocks.value[index].hasSlots) {
+            onItemBlockDrop(new BlockDropEvent(block, contentData), flatBlocks.value[index]);
+          } else {
+            onPlaceBlockDrop(new BlockDropEvent(block, contentData), index);
+          }
+        } else {
+          onPlaceBlockDrop(new BlockDropEvent(block, contentData), flatBlocks.value.length);
+        }
+      } catch (e) {
+        console.warn(e);
+      }
+    };
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", {
+        ref_key: "containerRef",
+        ref: containerRef,
+        class: "page-editor-hierarchy",
+        onClick: _cache[1] || (_cache[1] = withModifiers(($event) => emit("update:activeBlockId", null), ["self"]))
+      }, [
+        (openBlock(true), createElementBlock(Fragment, null, renderList(flatBlocks.value, (item) => {
+          return openBlock(), createElementBlock("div", {
+            class: normalizeClass(["page-editor-hierarchy__item", { active: props.activeBlockId === item.content.id, hover: props.hoverBlockId === item.content.id }]),
+            style: normalizeStyle({ paddingLeft: `${16 + item.intent * 16}px` }),
+            onBlockdrop: ($event) => onItemBlockDrop($event, item),
+            onMousedown: ($event) => onItemMouseDown($event, item),
+            onMouseenter: ($event) => emit("update:hoverBlockId", item.content.id),
+            onMouseleave: _cache[0] || (_cache[0] = ($event) => emit("update:hoverBlockId", null)),
+            onClick: ($event) => emit("update:activeBlockId", item.content.id),
+            onContextmenu: withModifiers(($event) => unref(contextMenu).open($event, item.content), ["stop"])
+          }, toDisplayString(item.block.name), 47, _hoisted_1$f);
+        }), 256)),
+        (openBlock(true), createElementBlock(Fragment, null, renderList(unref(places), (item) => {
+          return openBlock(), createElementBlock("div", {
+            class: "page-editor-hierarhy__place",
+            style: normalizeStyle(item.style),
+            onBlockdrop: ($event) => onPlaceBlockDrop($event, item.index)
+          }, null, 44, _hoisted_2$4);
+        }), 256)),
+        createVNode(_sfc_main$j, normalizeProps(guardReactiveProps(unref(contextMenu).props)), null, 16)
+      ], 512);
+    };
+  }
+});
+const _sfc_main$h = /* @__PURE__ */ defineComponent({
+  __name: "HoverFrame",
+  props: {
+    element: {},
+    resizable: { type: Boolean }
+  },
+  setup(__props) {
+    const props = __props;
+    const style = ref({ display: "none" });
+    const updateStyle = () => {
+      if (props.element) {
+        const rect = props.element.getBoundingClientRect();
+        style.value = {
+          top: rect.top + document.documentElement.scrollTop + "px",
+          left: rect.left + document.documentElement.scrollLeft + "px",
+          width: rect.width + "px",
+          height: rect.height + "px"
+        };
+      } else {
+        style.value = { display: "none" };
+      }
+    };
+    const resizeObserver = new ResizeObserver(updateStyle);
+    watch(() => props.element, (element, lastElement) => {
+      updateStyle();
+      if (element) {
+        resizeObserver.observe(element);
+      } else if (lastElement) {
+        resizeObserver.unobserve(lastElement);
+      }
+    }, { immediate: true });
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", {
+        class: "editor-component editor-hover-frame",
+        style: normalizeStyle(style.value)
+      }, null, 4);
+    };
+  }
+});
+const _hoisted_1$e = ["onClick"];
+const _sfc_main$g = /* @__PURE__ */ defineComponent({
+  __name: "VTabs",
+  props: {
+    items: {},
+    modelValue: {}
+  },
+  emits: ["update:modelValue"],
+  setup(__props, { emit: __emit }) {
+    const props = __props;
+    const emit = __emit;
+    const model = useVModel(props, "modelValue", emit, { passive: true });
+    watch(() => props.items, (items) => {
+      if ((model.value === void 0 || model.value === null) && items.length > 0) {
+        model.value = items[0].id;
+      }
+    }, { immediate: true });
+    const tabsRef = ref();
+    const markerStyle = ref({});
+    const placeMarker = () => {
+      const id = model.value;
+      if (!tabsRef.value) return;
+      const index = props.items.findIndex((item) => item.id === id);
+      if (index < 0) {
+        markerStyle.value = { width: "0px" };
+        return;
+      }
+      const child = tabsRef.value.children[index];
+      const p = 8;
+      markerStyle.value = { left: child.offsetLeft + p + "px", width: child.clientWidth - p * 2 + "px" };
+      for (let child2 of tabsRef.value.children) {
+        const item = child2;
+        item.style.left = item.offsetLeft + "px";
+      }
+    };
+    onMounted(() => {
+      placeMarker();
+    });
+    watch(() => props.items, () => {
+      placeMarker();
+    }, { deep: true, flush: "post" });
+    watch(model, placeMarker, { flush: "post" });
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", {
+        ref_key: "tabsRef",
+        ref: tabsRef,
+        class: "v-tabs"
+      }, [
+        createVNode(TransitionGroup, null, {
+          default: withCtx(() => [
+            (openBlock(true), createElementBlock(Fragment, null, renderList(props.items, (item) => {
+              return openBlock(), createElementBlock("button", {
+                key: item.id,
+                class: normalizeClass(["v-tabs__tab", { active: unref(model) === item.id }]),
+                onClick: ($event) => model.value = item.id
+              }, toDisplayString(item.title), 11, _hoisted_1$e);
+            }), 128))
+          ]),
+          _: 1
+        }),
+        createElementVNode("div", {
+          class: "v-tabs__marker",
+          style: normalizeStyle(markerStyle.value)
+        }, null, 4)
+      ], 512);
+    };
+  }
+});
+const _hoisted_1$d = { class: "v-tabs-pages" };
+const _sfc_main$f = /* @__PURE__ */ defineComponent({
+  __name: "VTabsPages",
+  props: {
+    page: {},
+    "page:class": {}
+  },
+  setup(__props) {
+    const props = __props;
+    const slots = useSlots();
+    const transitionClass = ref("slide-right");
+    watch(() => props.page, (value, lastValue) => {
+      const keys = Object.keys(slots);
+      if (keys.indexOf(value) > keys.indexOf(lastValue)) {
+        transitionClass.value = "slide-left";
+      } else {
+        transitionClass.value = "slide-right";
+      }
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", _hoisted_1$d, [
+        createVNode(Transition, { name: transitionClass.value }, {
+          default: withCtx(() => [
+            (openBlock(), createElementBlock("div", {
+              key: props.page,
+              class: normalizeClass(["v-tabs-pages__page", props["page:class"]])
+            }, [
+              renderSlot(_ctx.$slots, props.page)
+            ], 2))
+          ]),
+          _: 3
+        }, 8, ["name"])
+      ]);
+    };
+  }
+});
+const _hoisted_1$c = {
+  key: 0,
+  class: "v-form-control__label"
+};
+const _hoisted_2$3 = {
+  key: 0,
+  class: "v-form-control__required-marker"
+};
+const _hoisted_3$3 = {
+  key: 1,
+  class: "v-form-control__outline"
+};
+const _hoisted_4$3 = {
+  key: 3,
+  class: "v-form-control__actions"
+};
+const _hoisted_5$1 = {
+  key: 0,
+  class: "v-form-control__error"
+};
+const _sfc_main$e = /* @__PURE__ */ defineComponent({
+  __name: "VFormControl",
+  props: {
+    error: {},
+    label: {},
+    required: { type: Boolean },
+    disabled: { type: Boolean },
+    outline: { type: Boolean }
+  },
+  setup(__props) {
+    const props = __props;
+    const error = computed(() => {
+      if (!props.error) return "";
+      const code = props.error["code"];
+      if (code) {
+        return props.error.message ?? "";
+      }
+      return props.error.message ?? "Произошла ошибка";
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", {
+        class: normalizeClass(["v-form-control", { error: !!props.error, disabled: props.disabled }])
+      }, [
+        !!props.label ? (openBlock(), createElementBlock("label", _hoisted_1$c, [
+          createTextVNode(toDisplayString(props.label), 1),
+          props.required ? (openBlock(), createElementBlock("span", _hoisted_2$3, "*")) : createCommentVNode("", true)
+        ])) : createCommentVNode("", true),
+        props.outline ? (openBlock(), createElementBlock("div", _hoisted_3$3, [
+          renderSlot(_ctx.$slots, "default")
+        ])) : renderSlot(_ctx.$slots, "default", { key: 2 }),
+        _ctx.$slots.actions ? (openBlock(), createElementBlock("div", _hoisted_4$3, [
+          renderSlot(_ctx.$slots, "actions")
+        ])) : createCommentVNode("", true),
+        createVNode(Transition, null, {
+          default: withCtx(() => [
+            !!props.error ? (openBlock(), createElementBlock("div", _hoisted_5$1, toDisplayString(error.value), 1)) : createCommentVNode("", true)
+          ]),
+          _: 1
+        })
+      ], 2);
+    };
+  }
+});
+const _hoisted_1$b = {
+  key: 0,
+  class: "v-input__start-adornment"
+};
+const _hoisted_2$2 = ["placeholder", "rows", "name"];
+const _hoisted_3$2 = ["placeholder", "type", "name"];
+const _hoisted_4$2 = {
+  key: 3,
+  class: "v-input__max-length"
+};
+const _sfc_main$d = /* @__PURE__ */ defineComponent({
+  __name: "VInput",
+  props: {
+    modelValue: {},
+    multiline: { type: Boolean },
+    autofocus: { type: Boolean },
+    rows: {},
+    placeholder: {},
+    type: {},
+    name: {},
+    large: { type: Boolean },
+    maxLength: {},
+    validator: { type: Function },
+    error: {},
+    label: {},
+    required: { type: Boolean },
+    disabled: { type: Boolean }
+  },
+  emits: ["update:modelValue"],
+  setup(__props, { emit: __emit }) {
+    const props = __props;
+    const emit = __emit;
+    const parse = (value) => {
+      if (props.validator) {
+        return props.validator(value);
+      }
+      if (props.type === "number") {
+        const val = parseFloat(value);
+        if (isNaN(val)) return null;
+        return val;
+      }
+      if (props.type === "integer") {
+        const val = parseInt(value);
+        if (isNaN(val)) return null;
+        return val;
+      }
+      return value;
+    };
+    let lastValue = "";
+    const model = ref("");
+    watch(() => props.modelValue, (value) => {
+      if (value === lastValue) return;
+      model.value = (value ?? "").toString();
+    }, { immediate: true });
+    watch(() => model.value, (modelValue) => {
+      const val = parse(modelValue);
+      lastValue = val;
+      emit("update:modelValue", val);
+    });
+    const error = computed(() => {
+      if ((props.type === "number" || props.type === "integer") && model.value && props.modelValue === null) {
+        return { message: "Введите числовое значение" };
+      }
+      return props.error;
+    });
+    const inputType = computed(() => {
+      if (props.type !== "phone" && props.type !== "number" && props.type !== "integer") return props.type;
+      return void 0;
+    });
+    const inputRef = ref();
+    onMounted(() => {
+      var _a;
+      if (props.autofocus || props.error) {
+        (_a = inputRef.value) == null ? void 0 : _a.focus();
+      }
+    });
+    if (props.multiline) {
+      useTextareaAutosize({ element: inputRef, input: model });
+    }
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(_sfc_main$e, {
+        class: normalizeClass(["v-input", { large: _ctx.large, multiline: _ctx.multiline }]),
+        error: error.value,
+        label: _ctx.label,
+        required: _ctx.required,
+        disabled: _ctx.disabled,
+        outline: ""
+      }, createSlots({
+        default: withCtx(() => [
+          renderSlot(_ctx.$slots, "start-adornment"),
+          _ctx.type === "phone" ? (openBlock(), createElementBlock("div", _hoisted_1$b, "+7")) : createCommentVNode("", true),
+          props.multiline ? withDirectives((openBlock(), createElementBlock("textarea", {
+            key: 1,
+            ref_key: "inputRef",
+            ref: inputRef,
+            "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => model.value = $event),
+            placeholder: props.placeholder,
+            rows: props.rows,
+            class: "scroll",
+            name: props.name
+          }, null, 8, _hoisted_2$2)), [
+            [vModelText, model.value]
+          ]) : withDirectives((openBlock(), createElementBlock("input", {
+            key: 2,
+            ref_key: "inputRef",
+            ref: inputRef,
+            "onUpdate:modelValue": _cache[1] || (_cache[1] = ($event) => model.value = $event),
+            placeholder: props.placeholder,
+            type: inputType.value,
+            name: props.name
+          }, null, 8, _hoisted_3$2)), [
+            [vModelDynamic, model.value]
+          ]),
+          props.maxLength ? (openBlock(), createElementBlock("div", _hoisted_4$2, toDisplayString(model.value.length) + " / " + toDisplayString(props.maxLength), 1)) : createCommentVNode("", true),
+          renderSlot(_ctx.$slots, "end-adornment")
+        ]),
+        _: 2
+      }, [
+        _ctx.$slots.actions ? {
+          name: "actions",
+          fn: withCtx(() => [
+            renderSlot(_ctx.$slots, "actions")
+          ]),
+          key: "0"
+        } : void 0
+      ]), 1032, ["error", "label", "required", "disabled", "class"]);
+    };
+  }
+});
+const _export_sfc = (sfc, props) => {
+  const target = sfc.__vccOpts || sfc;
+  for (const [key, val] of props) {
+    target[key] = val;
+  }
+  return target;
+};
+const _sfc_main$c = {};
+const _hoisted_1$a = {
+  width: "20",
+  height: "20",
+  viewBox: "0 0 20 20",
+  fill: "none",
+  xmlns: "http://www.w3.org/2000/svg"
+};
+function _sfc_render$5(_ctx, _cache) {
+  return openBlock(), createElementBlock("svg", _hoisted_1$a, _cache[0] || (_cache[0] = [
+    createElementVNode("path", {
+      "fill-rule": "evenodd",
+      "clip-rule": "evenodd",
+      d: "M7.5001 14.1665C7.50013 14.3313 7.54902 14.4924 7.64059 14.6294C7.73217 14.7664 7.8623 14.8732 8.01455 14.9362C8.1668 14.9993 8.33433 15.0158 8.49596 14.9836C8.65758 14.9515 8.80605 14.8722 8.9226 14.7557L13.0893 10.589C13.2455 10.4327 13.3333 10.2208 13.3333 9.99982C13.3333 9.77885 13.2455 9.56693 13.0893 9.41066L8.9226 5.24399C8.80605 5.12748 8.65758 5.04814 8.49596 5.016C8.33433 4.98386 8.1668 5.00037 8.01455 5.06342C7.8623 5.12648 7.73217 5.23327 7.6406 5.37027C7.54902 5.50728 7.50013 5.66836 7.5001 5.83316L7.5001 14.1665Z",
+      fill: "currentColor"
+    }, null, -1)
+  ]));
+}
+const CollapseArrowIcon = /* @__PURE__ */ _export_sfc(_sfc_main$c, [["render", _sfc_render$5]]);
+const _sfc_main$b = /* @__PURE__ */ defineComponent({
+  __name: "VCollapse",
+  props: {
+    open: { type: Boolean },
+    label: {},
+    withPadding: { type: Boolean }
+  },
+  emits: ["update:open"],
+  setup(__props, { emit: __emit }) {
+    const props = __props;
+    const emit = __emit;
+    const height = ref(0);
+    const open = ref(props.open ?? false);
+    const transition = ref(false);
+    const innerRef = ref();
+    let hideTimeout = null;
+    const setOpen = async (value) => {
+      open.value = value;
+      if (hideTimeout !== null) {
+        clearTimeout(hideTimeout);
+        hideTimeout = null;
+      }
+      if (open.value === false && innerRef.value) {
+        height.value = innerRef.value.clientHeight;
+      }
+      transition.value = true;
+      await nextTick();
+      await new Promise((res) => requestAnimationFrame(res));
+      if (open.value) {
+        height.value = innerRef.value.clientHeight;
+      } else {
+        height.value = 0;
+      }
+      hideTimeout = setTimeout(() => {
+        transition.value = false;
+      }, 200);
+      setTimeout(() => mouseMove = true, 0);
+      emit("update:open", open.value);
+    };
+    const onClick = async () => {
+      setOpen(!open.value);
+    };
+    watch(() => props.open, (value) => {
+      if (typeof value !== "boolean" || open.value === value) return;
+      setOpen(value);
+    });
+    let mouseMove = false;
+    useEventListener("mousedown", () => mouseMove = false);
+    const onMouseEnter = (e) => {
+      if (e.buttons > 0 && !mouseMove && !document.body.classList.contains("mousedrag")) {
+        mouseMove = true;
+        onClick();
+      }
+    };
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", {
+        class: normalizeClass(["v-collapse", { open: open.value }])
+      }, [
+        renderSlot(_ctx.$slots, "activator", {
+          props: { onClick, open: open.value }
+        }, () => [
+          createElementVNode("div", {
+            class: normalizeClass(["v-collapse__activator", { open: open.value }]),
+            onMousedown: onClick,
+            onMouseenter: onMouseEnter
+          }, [
+            createVNode(CollapseArrowIcon),
+            createElementVNode("div", null, toDisplayString(props.label), 1)
+          ], 34)
+        ]),
+        createElementVNode("div", {
+          class: normalizeClass(["v-collapse__content", { "v-transition": transition.value, withPadding: props.withPadding }]),
+          style: normalizeStyle(transition.value ? { height: `${height.value}px` } : void 0)
+        }, [
+          transition.value || open.value ? (openBlock(), createElementBlock("div", {
+            key: 0,
+            ref_key: "innerRef",
+            ref: innerRef,
+            class: "v-collapse__content-inner"
+          }, [
+            renderSlot(_ctx.$slots, "default")
+          ], 512)) : createCommentVNode("", true)
+        ], 6)
+      ], 2);
+    };
+  }
+});
+const _sfc_main$a = {};
+const _hoisted_1$9 = {
+  width: "16",
+  height: "16",
+  viewBox: "0 0 16 16",
+  fill: "none",
+  xmlns: "http://www.w3.org/2000/svg"
+};
+function _sfc_render$4(_ctx, _cache) {
+  return openBlock(), createElementBlock("svg", _hoisted_1$9, _cache[0] || (_cache[0] = [
+    createElementVNode("path", {
+      d: "M14.364 5.293C14.1764 5.10553 13.9221 5.00021 13.657 5.00021C13.3918 5.00021 13.1375 5.10553 12.95 5.293L7.99995 10.243L3.04995 5.293C2.86135 5.11084 2.60875 5.01005 2.34655 5.01232C2.08435 5.0146 1.83354 5.11977 1.64813 5.30518C1.46272 5.49059 1.35756 5.7414 1.35528 6.0036C1.353 6.26579 1.45379 6.5184 1.63595 6.707L7.29295 12.364C7.48048 12.5515 7.73479 12.6568 7.99995 12.6568C8.26512 12.6568 8.51942 12.5515 8.70695 12.364L14.364 6.707C14.5514 6.51947 14.6567 6.26516 14.6567 6C14.6567 5.73483 14.5514 5.48053 14.364 5.293Z",
+      fill: "currentColor"
+    }, null, -1)
+  ]));
+}
+const ArrowDownIcon = /* @__PURE__ */ _export_sfc(_sfc_main$a, [["render", _sfc_render$4]]);
+const _hoisted_1$8 = { key: 0 };
+const _hoisted_2$1 = {
+  key: 1,
+  class: "v-select__placeholder"
+};
+const _hoisted_3$1 = { class: "v-select__menu" };
+const _hoisted_4$1 = {
+  key: 0,
+  class: "group-title"
+};
+const _hoisted_5 = ["onClick"];
+const _sfc_main$9 = /* @__PURE__ */ defineComponent({
+  __name: "VSelect",
+  props: {
+    items: {},
+    modelValue: {},
+    placeholder: {},
+    nullable: { type: Boolean },
+    error: {},
+    label: {},
+    required: { type: Boolean },
+    disabled: { type: Boolean }
+  },
+  emits: ["update:modelValue"],
+  setup(__props, { emit: __emit }) {
+    const props = __props;
+    const emit = __emit;
+    const model = useVModel(props, "modelValue", emit, { passive: true, defaultValue: null });
+    const currentItem = computed(() => {
+      if (model.value === null) return null;
+      return props.items.find((item) => typeof item !== "string" && item.id === model.value) ?? null;
+    });
+    const items = computed(() => {
+      return props.items;
+    });
+    const opened = ref(false);
+    const onItemClick = (item) => {
+      model.value = item.id;
+      opened.value = false;
+    };
+    const resetValue = () => {
+      model.value = null;
+      opened.value = false;
+    };
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(_sfc_main$e, {
+        outline: "",
+        class: "v-select",
+        label: props.label,
+        error: props.error,
+        disabled: props.disabled,
+        required: props.required
+      }, {
+        default: withCtx(() => [
+          createVNode(_sfc_main$l, {
+            open: opened.value,
+            "onUpdate:open": _cache[0] || (_cache[0] = ($event) => opened.value = $event),
+            placement: "bottom",
+            "fit-anchor": "",
+            offset: 8
+          }, {
+            activator: withCtx(({ props: activatorProps }) => [
+              createElementVNode("button", mergeProps({
+                class: ["v-select__activator", { opened: opened.value }]
+              }, activatorProps), [
+                currentItem.value ? (openBlock(), createElementBlock("div", _hoisted_1$8, toDisplayString(currentItem.value.title), 1)) : (openBlock(), createElementBlock("div", _hoisted_2$1, toDisplayString(props.placeholder ?? "Выберите значение"), 1)),
+                createVNode(ArrowDownIcon)
+              ], 16)
+            ]),
+            default: withCtx(() => [
+              createElementVNode("div", _hoisted_3$1, [
+                props.nullable ? (openBlock(), createElementBlock("button", {
+                  key: 0,
+                  class: "nullable-item",
+                  onClick: resetValue
+                }, " Пустое значение ")) : createCommentVNode("", true),
+                (openBlock(true), createElementBlock(Fragment, null, renderList(items.value, (item) => {
+                  return openBlock(), createElementBlock(Fragment, null, [
+                    typeof item === "string" ? (openBlock(), createElementBlock("div", _hoisted_4$1, toDisplayString(item), 1)) : (openBlock(), createElementBlock("button", {
+                      key: 1,
+                      onClick: ($event) => onItemClick(item)
+                    }, [
+                      renderSlot(_ctx.$slots, "item", { item }, () => [
+                        createTextVNode(toDisplayString(item.title), 1)
+                      ])
+                    ], 8, _hoisted_5))
+                  ], 64);
+                }), 256))
+              ])
+            ]),
+            _: 3
+          }, 8, ["open"])
+        ]),
+        _: 3
+      }, 8, ["label", "error", "disabled", "required"]);
+    };
+  }
+});
+const _hoisted_1$7 = { class: "json-editor__array" };
+const _sfc_main$8 = /* @__PURE__ */ defineComponent({
+  __name: "JsonEditorArray",
+  props: {
+    label: {},
+    schema: {},
+    modelValue: {},
+    expanded: { type: Boolean }
+  },
+  emits: ["update:modelValue"],
+  setup(__props, { emit: __emit }) {
+    var _a;
+    const props = __props;
+    const emit = __emit;
+    const childExpanded = ((_a = props.schema.items) == null ? void 0 : _a.type) === "object" && Object.keys(props.schema.items.properties).length < 2;
+    const length = ref(0);
+    const tempArray = ref([]);
+    if (props.schema.type === "array" && props.modelValue) {
+      length.value = props.modelValue.length ?? 0;
+      tempArray.value = [...props.modelValue];
+    }
+    watch(tempArray, () => {
+      var _a2;
+      if (((_a2 = props.schema.items) == null ? void 0 : _a2.type) === "object" && props.modelValue[0] === tempArray.value[0]) return;
+      emit("update:modelValue", tempArray.value.slice(0, length.value));
+    }, { deep: true });
+    watch(length, (length2) => {
+      for (let i = tempArray.value.length; i < length2; i++) {
+        tempArray.value[i] = props.schema.items ? getDefaultValue(props.schema.items) : null;
+      }
+      emit("update:modelValue", tempArray.value.slice(0, length2));
+    });
+    const label = computed(() => {
+      return `${props.label} (${length.value})`;
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", _hoisted_1$7, [
+        createVNode(_sfc_main$b, {
+          label: label.value,
+          open: props.expanded
+        }, {
+          default: withCtx(() => [
+            createVNode(_sfc_main$d, {
+              label: "Количество элементов",
+              modelValue: length.value,
+              "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => length.value = $event),
+              type: "number"
+            }, null, 8, ["modelValue"]),
+            (openBlock(true), createElementBlock(Fragment, null, renderList(length.value, (index) => {
+              return openBlock(), createBlock(_sfc_main$4, {
+                key: index,
+                schema: props.schema.items,
+                name: `${props.schema.itemName ?? "Элемент"} ${index}`,
+                modelValue: tempArray.value[index - 1],
+                "onUpdate:modelValue": ($event) => tempArray.value[index - 1] = $event,
+                expanded: unref(childExpanded)
+              }, null, 8, ["schema", "name", "modelValue", "onUpdate:modelValue", "expanded"]);
+            }), 128))
+          ]),
+          _: 1
+        }, 8, ["label", "open"])
+      ]);
+    };
+  }
+});
+const _sfc_main$7 = {};
+const _hoisted_1$6 = {
+  width: "46",
+  height: "28",
+  viewBox: "0 0 46 28",
+  fill: "none",
+  xmlns: "http://www.w3.org/2000/svg"
+};
+function _sfc_render$3(_ctx, _cache) {
+  return openBlock(), createElementBlock("svg", _hoisted_1$6, _cache[0] || (_cache[0] = [
+    createStaticVNode('<mask id="mask0_1044_6" style="mask-type:luminance;" maskUnits="userSpaceOnUse" x="0" y="0" width="46" height="28"><path d="M45.5 0H0.5V28H45.5V0Z" fill="white"></path></mask><g mask="url(#mask0_1044_6)"><path d="M23.5 27.8537C35.9264 27.8537 46 25.6664 46 22.9683C46 20.2702 35.9264 18.083 23.5 18.083C11.0736 18.083 1 20.2702 1 22.9683C1 25.6664 11.0736 27.8537 23.5 27.8537Z" fill="#D7D7D7"></path><path d="M39.6719 9.5459L32.538 1.51859C32.1955 0.971432 31.6956 0.640625 31.169 0.640625H15.831C15.3044 0.640625 14.8045 0.971432 14.462 1.51789L7.32812 9.5466V15.9946H39.6719V9.5459Z" stroke="#A0A0A0" stroke-width="0.703125"></path><path d="M30.2591 11.7594C30.2591 10.6393 30.958 9.71457 31.825 9.71387H39.6719V22.3718C39.6719 23.8534 38.7437 25.0678 37.5977 25.0678H9.40234C8.25625 25.0678 7.32812 23.8527 7.32812 22.3718V9.71387H15.175C16.042 9.71387 16.7409 10.6372 16.7409 11.7573V11.7727C16.7409 12.8928 17.4475 13.7973 18.3138 13.7973H28.6862C29.5525 13.7973 30.2591 12.8845 30.2591 11.7643V11.7594Z" fill="#FAFAFA" stroke="#A0A0A0" stroke-width="0.703125"></path></g>', 2)
+  ]));
+}
+const EmptyFileIcon = /* @__PURE__ */ _export_sfc(_sfc_main$7, [["render", _sfc_render$3]]);
+const _sfc_main$6 = {};
+const _hoisted_1$5 = {
+  width: "16",
+  height: "16",
+  viewBox: "0 0 16 16",
+  fill: "none",
+  xmlns: "http://www.w3.org/2000/svg"
+};
+function _sfc_render$2(_ctx, _cache) {
+  return openBlock(), createElementBlock("svg", _hoisted_1$5, _cache[0] || (_cache[0] = [
+    createElementVNode("path", {
+      d: "M9.31382 7.9L12.8488 4.364C12.9443 4.27176 13.0205 4.16141 13.0729 4.03941C13.1253 3.9174 13.1529 3.78618 13.1541 3.6534C13.1552 3.52062 13.1299 3.38894 13.0796 3.26605C13.0294 3.14315 12.9551 3.0315 12.8612 2.93761C12.7673 2.84371 12.6557 2.76946 12.5328 2.71918C12.4099 2.6689 12.2782 2.6436 12.1454 2.64475C12.0126 2.64591 11.8814 2.67349 11.7594 2.7259C11.6374 2.77831 11.5271 2.85449 11.4348 2.95L7.89882 6.485L4.36382 2.95C4.27157 2.85449 4.16123 2.77831 4.03922 2.7259C3.91722 2.67349 3.786 2.64591 3.65322 2.64475C3.52044 2.6436 3.38876 2.6689 3.26587 2.71918C3.14297 2.76946 3.03132 2.84371 2.93742 2.93761C2.84353 3.0315 2.76928 3.14315 2.719 3.26605C2.66872 3.38894 2.64342 3.52062 2.64457 3.6534C2.64572 3.78618 2.67331 3.9174 2.72572 4.03941C2.77813 4.16141 2.85431 4.27176 2.94982 4.364L6.48482 7.899L2.94982 11.435C2.85431 11.5273 2.77813 11.6376 2.72572 11.7596C2.67331 11.8816 2.64572 12.0128 2.64457 12.1456C2.64342 12.2784 2.66872 12.4101 2.719 12.533C2.76928 12.6559 2.84353 12.7675 2.93742 12.8614C3.03132 12.9553 3.14297 13.0295 3.26587 13.0798C3.38876 13.1301 3.52044 13.1554 3.65322 13.1543C3.786 13.1531 3.91722 13.1255 4.03922 13.0731C4.16123 13.0207 4.27157 12.9445 4.36382 12.849L7.89882 9.314L11.4348 12.849C11.5271 12.9445 11.6374 13.0207 11.7594 13.0731C11.8814 13.1255 12.0126 13.1531 12.1454 13.1543C12.2782 13.1554 12.4099 13.1301 12.5328 13.0798C12.6557 13.0295 12.7673 12.9553 12.8612 12.8614C12.9551 12.7675 13.0294 12.6559 13.0796 12.533C13.1299 12.4101 13.1552 12.2784 13.1541 12.1456C13.1529 12.0128 13.1253 11.8816 13.0729 11.7596C13.0205 11.6376 12.9443 11.5273 12.8488 11.435L9.31382 7.9Z",
+      fill: "currentColor"
+    }, null, -1)
+  ]));
+}
+const CloseMinIcon = /* @__PURE__ */ _export_sfc(_sfc_main$6, [["render", _sfc_render$2]]);
+const _hoisted_1$4 = {
+  key: 0,
+  class: "v-image-uploader__drag-label"
+};
+const _hoisted_2 = { class: "v-image-uploader__image-preview" };
+const _hoisted_3 = ["src"];
+const _hoisted_4 = { class: "v-image-uploader__image-info" };
+const _sfc_main$5 = /* @__PURE__ */ defineComponent({
+  __name: "VImageUploader",
+  props: {
+    accept: {},
+    schema: {},
+    modelValue: {},
+    error: {},
+    label: {},
+    required: { type: Boolean },
+    disabled: { type: Boolean }
+  },
+  emits: ["update:modelValue"],
+  setup(__props, { emit: __emit }) {
+    const props = __props;
+    const emit = __emit;
+    const fileUploader = inject("fileUploader");
+    const addFile = async (file) => {
+      emit("update:modelValue", { src: URL.createObjectURL(file), file, name: file.name });
+      if (fileUploader) {
+        const resp = await fileUploader(file);
+        emit("update:modelValue", { src: resp.src, previewSrc: resp.previewSrc, name: resp.name });
+      }
+    };
+    const drag = ref(false);
+    const onDragOver = (e) => {
+      var _a, _b, _c;
+      if ((_c = (_b = (_a = e.dataTransfer) == null ? void 0 : _a.types) == null ? void 0 : _b[0]) == null ? void 0 : _c.startsWith("text")) return;
+      e.preventDefault();
+      drag.value = true;
+    };
+    const onDragLeave = (e) => {
+      var _a;
+      if (e.relatedTarget === e.currentTarget || ((_a = e.relatedTarget) == null ? void 0 : _a.parentElement) === e.currentTarget) return;
+      drag.value = false;
+    };
+    const onDrop = (e) => {
+      e.preventDefault();
+      drag.value = false;
+      for (const item of e.dataTransfer.items) {
+        if (item.kind !== "file") continue;
+        const file = item.getAsFile();
+        if (!file) continue;
+        addFile(file);
+      }
+    };
+    const fileDialog = useFileDialog({
+      accept: props.accept ?? "image/*",
+      multiple: false
+    });
+    fileDialog.onChange((files) => {
+      if (!files || files.length === 0) return;
+      for (const file of files) {
+        addFile(file);
+      }
+      fileDialog.reset();
+    });
+    const removeImage = () => {
+      emit("update:modelValue", getDefaultValue(props.schema));
+    };
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(_sfc_main$e, {
+        class: normalizeClass(["v-image-uploader", { drag: drag.value }]),
+        error: _ctx.error,
+        label: _ctx.label,
+        required: _ctx.required,
+        disabled: _ctx.disabled,
+        outline: "",
+        onDrop,
+        onDragover: onDragOver,
+        onDragleave: onDragLeave
+      }, {
+        default: withCtx(() => [
+          drag.value ? (openBlock(), createElementBlock("div", _hoisted_1$4, "Отпустите файл здесь")) : !props.modelValue || props.modelValue.src === unref(defaultImageSrc) ? (openBlock(), createElementBlock(Fragment, { key: 1 }, [
+            createVNode(EmptyFileIcon),
+            createElementVNode("div", null, [
+              createElementVNode("a", {
+                onClick: _cache[0] || (_cache[0] = ($event) => unref(fileDialog).open())
+              }, "Загрузите изображение"),
+              _cache[1] || (_cache[1] = createElementVNode("br", null, null, -1)),
+              _cache[2] || (_cache[2] = createTextVNode("или перетащите сюда "))
+            ])
+          ], 64)) : (openBlock(), createElementBlock(Fragment, { key: 2 }, [
+            createElementVNode("div", _hoisted_2, [
+              createElementVNode("img", {
+                src: props.modelValue.previewSrc ?? props.modelValue.src,
+                alt: "Preview Image"
+              }, null, 8, _hoisted_3),
+              createElementVNode("button", { onClick: removeImage }, [
+                createVNode(CloseMinIcon)
+              ])
+            ]),
+            createElementVNode("div", _hoisted_4, [
+              createElementVNode("div", null, toDisplayString(props.modelValue.name), 1)
+            ])
+          ], 64))
+        ]),
+        _: 1
+      }, 8, ["class", "error", "label", "required", "disabled"]);
+    };
+  }
+});
+const getBlockName = (path) => {
+  if (!path) return void 0;
+  const str = path.split("/").at(-1);
+  return (str == null ? void 0 : str.split(".", 1)[0].replace(/([A-Z])/g, " $1").trimStart()) ?? "Unnamed block";
+};
+const capitalize = (text) => {
+  return text[0].toUpperCase() + text.slice(1);
+};
+const spaceCamelCase = (str) => {
+  return capitalize(str.replace(/([A-Z])/g, " $1").trimStart());
+};
+const _hoisted_1$3 = {
+  key: 1,
+  class: "json-editor__object"
+};
+const _sfc_main$4 = /* @__PURE__ */ defineComponent({
+  __name: "JsonEditor",
+  props: /* @__PURE__ */ mergeModels({
+    schema: {},
+    name: {},
+    flat: { type: Boolean },
+    expanded: { type: Boolean }
+  }, {
+    "modelValue": {},
+    "modelModifiers": {}
+  }),
+  emits: ["update:modelValue"],
+  setup(__props) {
+    const props = __props;
+    const childExpanded = props.schema.type === "object" && Object.keys(props.schema.properties).length < 2;
+    const vModel = useModel(__props, "modelValue");
+    const getItems = (schema) => {
+      return schema.enum.map((item, index) => {
+        var _a;
+        return {
+          id: item,
+          title: ((_a = schema.enumAlias) == null ? void 0 : _a[index]) ?? spaceCamelCase(item)
+        };
+      });
+    };
+    return (_ctx, _cache) => {
+      const _component_JsonEditor = resolveComponent("JsonEditor", true);
+      return props.schema.type === "object" && props.schema.format === "image" ? (openBlock(), createBlock(_sfc_main$5, {
+        key: 0,
+        modelValue: vModel.value,
+        "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => vModel.value = $event),
+        label: props.schema.name ?? props.name,
+        schema: props.schema
+      }, null, 8, ["modelValue", "label", "schema"])) : props.schema.type === "object" ? (openBlock(), createElementBlock("div", _hoisted_1$3, [
+        props.flat ? (openBlock(true), createElementBlock(Fragment, { key: 0 }, renderList(props.schema.properties, (item, key) => {
+          return openBlock(), createBlock(_component_JsonEditor, {
+            modelValue: vModel.value[key],
+            "onUpdate:modelValue": ($event) => vModel.value[key] = $event,
+            key,
+            schema: item,
+            expanded: unref(childExpanded),
+            name: unref(spaceCamelCase)(key)
+          }, null, 8, ["modelValue", "onUpdate:modelValue", "schema", "expanded", "name"]);
+        }), 128)) : (openBlock(), createBlock(_sfc_main$b, {
+          key: 1,
+          label: props.schema.name ?? props.name,
+          open: props.expanded
+        }, {
+          default: withCtx(() => [
+            (openBlock(true), createElementBlock(Fragment, null, renderList(props.schema.properties, (item, key) => {
+              return openBlock(), createBlock(_component_JsonEditor, {
+                modelValue: vModel.value[key],
+                "onUpdate:modelValue": ($event) => vModel.value[key] = $event,
+                key,
+                schema: item,
+                expanded: unref(childExpanded),
+                name: unref(spaceCamelCase)(key)
+              }, null, 8, ["modelValue", "onUpdate:modelValue", "schema", "expanded", "name"]);
+            }), 128))
+          ]),
+          _: 1
+        }, 8, ["label", "open"]))
+      ])) : props.schema.type === "array" ? (openBlock(), createBlock(_sfc_main$8, {
+        key: 2,
+        modelValue: vModel.value,
+        "onUpdate:modelValue": _cache[1] || (_cache[1] = ($event) => vModel.value = $event),
+        schema: props.schema,
+        label: props.schema.name ?? props.name,
+        expanded: props.expanded
+      }, null, 8, ["modelValue", "schema", "label", "expanded"])) : props.schema.type === "string" && props.schema.enum ? (openBlock(), createBlock(_sfc_main$9, {
+        key: 3,
+        items: getItems(props.schema),
+        modelValue: vModel.value,
+        "onUpdate:modelValue": _cache[2] || (_cache[2] = ($event) => vModel.value = $event),
+        label: props.schema.name ?? props.name
+      }, null, 8, ["items", "modelValue", "label"])) : (openBlock(), createBlock(_sfc_main$d, {
+        key: 4,
+        modelValue: vModel.value,
+        "onUpdate:modelValue": _cache[3] || (_cache[3] = ($event) => vModel.value = $event),
+        label: props.schema.name ?? props.name,
+        multiline: props.schema.multiline
+      }, null, 8, ["modelValue", "label", "multiline"]));
+    };
+  }
+});
+const _sfc_main$3 = {};
+const _hoisted_1$2 = {
+  width: "16",
+  height: "16",
+  viewBox: "0 0 16 16",
+  fill: "none",
+  xmlns: "http://www.w3.org/2000/svg"
+};
+function _sfc_render$1(_ctx, _cache) {
+  return openBlock(), createElementBlock("svg", _hoisted_1$2, _cache[0] || (_cache[0] = [
+    createElementVNode("path", {
+      d: "M10.707 14.364C10.8945 14.1764 10.9998 13.9221 10.9998 13.657C10.9998 13.3918 10.8945 13.1375 10.707 12.95L5.75705 7.99995L10.707 3.04995C10.8892 2.86135 10.99 2.60875 10.9877 2.34655C10.9854 2.08435 10.8803 1.83354 10.6949 1.64813C10.5095 1.46272 10.2586 1.35756 9.99645 1.35528C9.73425 1.353 9.48165 1.45379 9.29305 1.63595L3.63605 7.29295C3.44858 7.48048 3.34326 7.73479 3.34326 7.99995C3.34326 8.26512 3.44858 8.51942 3.63605 8.70695L9.29305 14.364C9.48058 14.5514 9.73488 14.6567 10 14.6567C10.2652 14.6567 10.5195 14.5514 10.707 14.364Z",
+      fill: "currentColor"
+    }, null, -1)
+  ]));
+}
+const ChevronLeftIcon = /* @__PURE__ */ _export_sfc(_sfc_main$3, [["render", _sfc_render$1]]);
+const _sfc_main$2 = {};
+const _hoisted_1$1 = {
+  width: "16",
+  height: "16",
+  viewBox: "0 0 16 16",
+  fill: "none",
+  xmlns: "http://www.w3.org/2000/svg"
+};
+function _sfc_render(_ctx, _cache) {
+  return openBlock(), createElementBlock("svg", _hoisted_1$1, _cache[0] || (_cache[0] = [
+    createElementVNode("path", {
+      d: "M5.29295 1.63605C5.10548 1.82358 5.00017 2.07788 5.00017 2.34305C5.00017 2.60821 5.10548 2.86252 5.29295 3.05005L10.243 8.00005L5.29295 12.95C5.11079 13.1387 5.01 13.3913 5.01228 13.6534C5.01456 13.9156 5.11972 14.1665 5.30513 14.3519C5.49054 14.5373 5.74135 14.6424 6.00355 14.6447C6.26575 14.647 6.51835 14.5462 6.70695 14.364L12.364 8.70705C12.5514 8.51952 12.6567 8.26521 12.6567 8.00005C12.6567 7.73488 12.5514 7.48058 12.364 7.29305L6.70695 1.63605C6.51942 1.44858 6.26512 1.34326 5.99995 1.34326C5.73479 1.34326 5.48048 1.44858 5.29295 1.63605Z",
+      fill: "currentColor"
+    }, null, -1)
+  ]));
+}
+const ChevronRightIcon = /* @__PURE__ */ _export_sfc(_sfc_main$2, [["render", _sfc_render]]);
+const useControlComponent = (_activeBlockId) => {
+  let lastRoot = document.body;
+  const hoverBlockId = shallowRef(null);
+  const activeBlockId = shallowRef(_activeBlockId ?? null);
+  const hoverBlockElement = shallowRef(null);
+  const activeBlockElement = shallowRef(null);
+  let lastStateKey = "";
+  let blocksHover = [];
+  const onIframeBlockMouseEnter = (e) => {
+    hoverBlockElement.value = e.currentTarget;
+    const blockId = hoverBlockElement.value.getAttribute("data-block-id") ?? null;
+    hoverBlockId.value = blockId;
+    blocksHover.push(e.currentTarget);
+  };
+  const onIframeBlockMouseLeave = (e) => {
+    const el = e.currentTarget;
+    if (el && blocksHover.indexOf(el) >= 0) {
+      blocksHover = blocksHover.slice(0, blocksHover.indexOf(el));
+    }
+    setTimeout(() => {
+      var _a;
+      if (hoverBlockElement.value !== el) return;
+      hoverBlockElement.value = blocksHover[blocksHover.length - 1] ?? null;
+      const blockId = ((_a = hoverBlockElement.value) == null ? void 0 : _a.getAttribute("data-block-id")) ?? null;
+      hoverBlockId.value = blockId;
+    }, 0);
+  };
+  const onIframeBlockClick = (e) => {
+    hoverBlockElement.value = e.currentTarget;
+    const blockId = hoverBlockElement.value.getAttribute("data-block-id") ?? null;
+    hoverBlockId.value = blockId;
+    activeBlockId.value = blockId;
+    if (!blockId) return;
+    activeBlockElement.value = hoverBlockElement.value;
+    e.stopPropagation();
+    e.preventDefault();
+  };
+  const update = (root) => {
+    lastRoot = root;
+    const arr = Array.from(root.querySelectorAll("[data-block-id]"));
+    const key = arr.map((item) => item.getAttribute("data-block-id") ?? "").join(",");
+    if (lastStateKey === key) return;
+    for (let item of arr) {
+      if (item.hasAttribute("data-dev")) continue;
+      item.addEventListener("mouseenter", onIframeBlockMouseEnter);
+      item.addEventListener("mouseleave", onIframeBlockMouseLeave);
+      item.addEventListener("click", onIframeBlockClick);
+    }
+  };
+  watch(hoverBlockId, (hoverBlockId2) => {
+    var _a;
+    if (hoverBlockId2 === null) {
+      hoverBlockElement.value = null;
+      return;
+    }
+    if (hoverBlockId2 === ((_a = hoverBlockElement.value) == null ? void 0 : _a.getAttribute("data-block-id"))) {
+      return;
+    }
+    hoverBlockElement.value = (lastRoot == null ? void 0 : lastRoot.querySelector(`[data-block-id="${hoverBlockId2}"]`)) ?? null;
+  });
+  watch(activeBlockId, (activeBlockId2) => {
+    var _a;
+    if (activeBlockId2 === null) {
+      activeBlockElement.value = null;
+      return;
+    }
+    if (activeBlockId2 === ((_a = activeBlockElement.value) == null ? void 0 : _a.getAttribute("data-block-id"))) {
+      return;
+    }
+    activeBlockElement.value = lastRoot.querySelector(`[data-block-id="${activeBlockId2}"]`) ?? null;
+  }, { immediate: true });
+  return {
+    update,
+    hoverBlockElement,
+    activeBlockElement,
+    activeBlockId,
+    hoverBlockId
+  };
+};
+registerAlias("image", { type: "object", format: "image", properties: { src: "string", previewSrc: "string?" } });
+registerAlias("file", { type: "object", format: "file", properties: { src: "string" } });
+const blocksList = blocksList$1.map((file) => ({
+  ...file.blockSchema,
+  id: file.blockSchema.id ?? file.__name,
+  order: file.blockSchema.order,
+  name: file.blockSchema.name ?? getBlockName(file.__name) ?? "Unnamed block",
+  props: file.blockSchema.props ? unfoldSchema(file.blockSchema.props) : {}
+}));
+const blocksMap = new Map(blocksList.map((item) => [item.id, item]));
+const processState = (state) => {
+  walkTree(state.content, (block) => {
+    if (block.id) {
+      block.id = uid();
+    }
+    if (!block.data) {
+      block.data = {};
+    }
+    block.data["data-block-id"] = block.id;
+    const schema = blocksMap.get(block.blockId);
+    if (!schema) return;
+    walkSchema(block.data, schema.props, (value, schema2, key, parent, isRequired) => {
+      if (key && isRequired && !schema2.nullable && (value === null || value === void 0)) {
+        parent[key] = getDefaultValue(schema2);
+      }
+    });
+  });
+  return state;
+};
+const saveState = (newState) => {
+  const state = cloneDeep(newState);
+  walkTree(state.content, (block) => {
+    if (!block.data) return;
+    delete block.data["data-block-id"];
+    const schema = blocksMap.get(block.blockId);
+    if (!schema) return;
+    walkSchema(block.data, schema.props, (value, schema2, key, parent) => {
+      if (schema2.type === "object" && schema2.format === "image" && value.src === defaultImageSrc && key && parent) {
+        parent[key] = null;
+      }
+    });
+  });
+  return state;
+};
+const _sfc_main$1 = /* @__PURE__ */ defineComponent({
+  __name: "PageSelector",
+  setup(__props) {
+    const currentPage = ref(window.state.dev.currentPage);
+    const availablePages = window.state.dev.availablePages;
+    const pages = availablePages.map((item) => ({
+      id: item,
+      title: item
+    }));
+    if (!availablePages.includes(currentPage.value)) {
+      pages.push({
+        id: currentPage.value,
+        title: currentPage.value
+      });
+    }
+    watch(currentPage, async (newPage) => {
+      var _a;
+      const resp = await fetch(`/${newPage}`);
+      const html = await resp.text();
+      const _state = (_a = html.match(/window\.state=({.+})/)) == null ? void 0 : _a[1];
+      const state = _state && JSON.parse(_state);
+      processState(state);
+      Object.assign(window.state, state);
+      window.history.pushState({}, "", newPage === "index" ? "/" : `/${newPage}`);
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(_sfc_main$9, {
+        modelValue: currentPage.value,
+        "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => currentPage.value = $event),
+        items: unref(pages)
+      }, null, 8, ["modelValue", "items"]);
+    };
+  }
+});
+const _hoisted_1 = { key: 1 };
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "EditorApp",
+  setup(__props) {
+    var _a, _b;
+    const controlsOpened = ref(true);
+    const dragMode = ref(false);
+    provide("dragMode", dragMode);
+    const contentBlocks = computed(() => window.state.content);
+    useEventListener(document, "blockdrop", (e) => {
+      if (e.content) {
+        return;
+      }
+      contentBlocks.value.push(createContentBlock(e.block));
+    });
+    const control = useControlComponent((_a = import.meta.hot) == null ? void 0 : _a.data.activeBlockId);
+    watch(contentBlocks, () => {
+      control.update(window.document.body);
+    }, { deep: true, flush: "post" });
+    onMounted(() => {
+      control.update(window.document.body);
+    });
+    const currentContentBlock = computed(() => {
+      if (!control.activeBlockId.value) return null;
+      return findBlock(contentBlocks.value, (block) => block.id === control.activeBlockId.value);
+    });
+    const currentBlock = computed(() => {
+      if (!currentContentBlock.value) return null;
+      return blocksMap.get(currentContentBlock.value.blockId);
+    });
+    const currentTab = ref(((_b = import.meta.hot) == null ? void 0 : _b.data.currentTab) ?? "blocks");
+    const tabs = computed(() => {
+      var _a2;
+      const arr = [
+        { id: "blocks", title: "Блоки" }
+      ];
+      if (currentContentBlock.value) {
+        arr.push({
+          id: "blockEdit",
+          title: ((_a2 = currentBlock.value) == null ? void 0 : _a2.name) ?? "Unknown Block"
+        });
+      }
+      return arr;
+    });
+    watch(currentContentBlock, (block) => {
+      if (block) {
+        currentTab.value = "blockEdit";
+      } else {
+        if (currentTab.value === "blockEdit") {
+          currentTab.value = "blocks";
+        }
+      }
+    });
+    watch(currentTab, (currentTab2) => {
+      Object.assign(import.meta.hot.data, { currentTab: currentTab2 });
+    });
+    watch(control.activeBlockId, (activeBlockId) => {
+      Object.assign(import.meta.hot.data, { activeBlockId });
+    });
+    useKeyDownLayer("Escape", () => !!control.activeBlockId.value, () => control.activeBlockId.value = null);
+    watchDebounced(window.state, (newState, oldState) => {
+      var _a2, _b2;
+      if (((_a2 = newState == null ? void 0 : newState.dev) == null ? void 0 : _a2.currentPage) !== ((_b2 = oldState == null ? void 0 : oldState.dev) == null ? void 0 : _b2.currentPage)) {
+        return;
+      }
+      const state = saveState(newState);
+      fetch("/@mechanica/save", {
+        method: "POST",
+        body: JSON.stringify(state),
+        headers: { "content-type": "application-json" }
+      });
+    }, { debounce: 500 });
+    provide("fileUploader", async (file) => {
+      const resp = await fetch("/@mechanica/upload", {
+        method: "POST",
+        body: file,
+        headers: { "x-file-name": file.name, "content-type": "application/octet-stream" }
+      });
+      const obj = await resp.json();
+      return obj;
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock(Fragment, null, [
+        createVNode(Transition, null, {
+          default: withCtx(() => [
+            controlsOpened.value ? (openBlock(), createElementBlock("div", {
+              key: 0,
+              class: "editor-sidebar-left editor-hierarchy editor-component",
+              onBlockdrop: _cache[3] || (_cache[3] = withModifiers(() => {
+              }, ["stop"]))
+            }, [
+              createVNode(_sfc_main$1),
+              _cache[10] || (_cache[10] = createElementVNode("div", { class: "title" }, "Блоки", -1)),
+              createVNode(_sfc_main$i, {
+                "hover-block-id": unref(control).hoverBlockId.value,
+                "onUpdate:hoverBlockId": _cache[0] || (_cache[0] = ($event) => unref(control).hoverBlockId.value = $event),
+                "active-block-id": unref(control).activeBlockId.value,
+                "onUpdate:activeBlockId": _cache[1] || (_cache[1] = ($event) => unref(control).activeBlockId.value = $event),
+                "content-blocks": contentBlocks.value,
+                "blocks-map": unref(blocksMap)
+              }, null, 8, ["hover-block-id", "active-block-id", "content-blocks", "blocks-map"]),
+              createElementVNode("button", {
+                class: "editor-sidebar__close-button",
+                onClick: _cache[2] || (_cache[2] = ($event) => controlsOpened.value = false)
+              }, [
+                createVNode(ChevronLeftIcon)
+              ])
+            ], 32)) : createCommentVNode("", true)
+          ]),
+          _: 1
+        }),
+        controlsOpened.value ? (openBlock(), createBlock(_sfc_main$h, {
+          key: 0,
+          element: unref(control).hoverBlockElement.value
+        }, null, 8, ["element"])) : createCommentVNode("", true),
+        controlsOpened.value ? (openBlock(), createBlock(_sfc_main$h, {
+          key: 1,
+          element: unref(control).activeBlockElement.value,
+          resizable: ""
+        }, null, 8, ["element"])) : createCommentVNode("", true),
+        createVNode(Transition, null, {
+          default: withCtx(() => [
+            controlsOpened.value ? (openBlock(), createElementBlock("div", {
+              key: 0,
+              class: "editor-sidebar-right editor-blocks-sidebar editor-component",
+              onBlockdrop: _cache[7] || (_cache[7] = withModifiers(() => {
+              }, ["stop"]))
+            }, [
+              createElementVNode("button", {
+                class: "editor-sidebar__close-button right",
+                onClick: _cache[4] || (_cache[4] = ($event) => controlsOpened.value = false)
+              }, [
+                createVNode(ChevronRightIcon)
+              ]),
+              createVNode(_sfc_main$g, {
+                modelValue: currentTab.value,
+                "onUpdate:modelValue": _cache[5] || (_cache[5] = ($event) => currentTab.value = $event),
+                items: tabs.value
+              }, null, 8, ["modelValue", "items"]),
+              createVNode(_sfc_main$f, { page: currentTab.value }, {
+                blocks: withCtx(() => [
+                  createVNode(_sfc_main$m, { blocks: unref(blocksList) }, null, 8, ["blocks"])
+                ]),
+                blockEdit: withCtx(() => [
+                  currentBlock.value && currentContentBlock.value ? (openBlock(), createBlock(_sfc_main$4, {
+                    key: currentContentBlock.value.id,
+                    schema: currentBlock.value.props,
+                    modelValue: currentContentBlock.value.data,
+                    "onUpdate:modelValue": _cache[6] || (_cache[6] = ($event) => currentContentBlock.value.data = $event),
+                    flat: ""
+                  }, null, 8, ["schema", "modelValue"])) : (openBlock(), createElementBlock("div", _hoisted_1, "Схема для блока не найдена"))
+                ]),
+                _: 1
+              }, 8, ["page"])
+            ], 32)) : createCommentVNode("", true)
+          ]),
+          _: 1
+        }),
+        createVNode(Transition, null, {
+          default: withCtx(() => [
+            !controlsOpened.value ? (openBlock(), createElementBlock("div", {
+              key: 0,
+              class: "editor-sidebar__close-button editor-component fixed",
+              onClick: _cache[8] || (_cache[8] = ($event) => controlsOpened.value = true)
+            }, [
+              createVNode(ChevronRightIcon)
+            ])) : createCommentVNode("", true)
+          ]),
+          _: 1
+        }),
+        createVNode(Transition, null, {
+          default: withCtx(() => [
+            !controlsOpened.value ? (openBlock(), createElementBlock("div", {
+              key: 0,
+              class: "editor-sidebar__close-button editor-component right fixed",
+              onClick: _cache[9] || (_cache[9] = ($event) => controlsOpened.value = true)
+            }, [
+              createVNode(ChevronLeftIcon)
+            ])) : createCommentVNode("", true)
+          ]),
+          _: 1
+        })
+      ], 64);
+    };
+  }
+});
+window.state = reactive(processState(window.state));
+const mountDiv = document.createElement("div");
+mountDiv.id = "data-mechanics-editor";
+document.body.append(mountDiv);
+document.addEventListener("DOMContentLoaded", () => {
+  createApp(_sfc_main).mount(mountDiv);
+});
+//# sourceMappingURL=editor.js.map