@parhelia/editor-bridge-head 0.1.12875

package/dist/host/v1/parhelia-bridge.js

@@ -0,0 +1,2699 @@
+"use strict";
+(() => {
+  // <define:__PARHELIA_BRIDGE_BUILD__>
+  var define_PARHELIA_BRIDGE_BUILD_default = { packageVersion: "#{VersionNumber}#", commit: "52e1923b", builtAt: "2026-06-06T14:31:46.468Z" };
+
+  // src/index.ts
+  var PARHELIA_EDITING_BRIDGE_FAMILY = "parhelia/editing-bridge";
+  var PARHELIA_EDITING_BRIDGE_VERSION = {
+    major: 1,
+    minor: 0
+  };
+
+  // src/host/origin.ts
+  var PARENT_ORIGIN_STORAGE_KEY = "parhelia:parentOrigin";
+  function normalizeOrigin(origin) {
+    try {
+      return new URL(origin).origin;
+    } catch (error) {
+      return void 0;
+    }
+  }
+  function normalizeOrigins(origins) {
+    return origins.map(function(origin) {
+      return normalizeOrigin(origin);
+    }).filter(Boolean);
+  }
+  function rememberParentOrigin(origin) {
+    if (!origin) return;
+    try {
+      sessionStorage.setItem(PARENT_ORIGIN_STORAGE_KEY, origin);
+    } catch (error) {
+    }
+  }
+  function readRememberedParentOrigin() {
+    try {
+      return normalizeOrigin(sessionStorage.getItem(PARENT_ORIGIN_STORAGE_KEY));
+    } catch (error) {
+      return void 0;
+    }
+  }
+  function resolveParentOrigin(config) {
+    config = config || {};
+    if (config.parentOrigin || config.editorOrigin) {
+      var configuredOrigin = normalizeOrigin(
+        config.parentOrigin || config.editorOrigin
+      );
+      rememberParentOrigin(configuredOrigin);
+      return configuredOrigin;
+    }
+    var referrerOrigin = document.referrer ? normalizeOrigin(document.referrer) : void 0;
+    if (referrerOrigin && referrerOrigin !== location.origin) {
+      rememberParentOrigin(referrerOrigin);
+      return referrerOrigin;
+    }
+    var rememberedOrigin = readRememberedParentOrigin();
+    if (rememberedOrigin) return rememberedOrigin;
+    if (referrerOrigin) {
+      rememberParentOrigin(referrerOrigin);
+      return referrerOrigin;
+    }
+    return void 0;
+  }
+
+  // src/host/runtime.ts
+  function isBridgeFamilyScriptSrc(src) {
+    if (!src) return false;
+    return src.indexOf("/parhelia-bridge.js") >= 0 || src.indexOf("/parhelia-stub.js") >= 0;
+  }
+
+  // src/host/parhelia-bridge.ts
+  (function() {
+    "use strict";
+    var family = PARHELIA_EDITING_BRIDGE_FAMILY;
+    var version = PARHELIA_EDITING_BRIDGE_VERSION;
+    var buildInfo = typeof define_PARHELIA_BRIDGE_BUILD_default !== "undefined" ? define_PARHELIA_BRIDGE_BUILD_default : {};
+    var operationalStarted = false;
+    var initFallbackTimer = 0;
+    var INIT_FALLBACK_MS = 2e3;
+    var acknowledgedCapabilities = null;
+    var config = window.__PARHELIA_EDITING_BRIDGE__ || {};
+    var parentWindow = window.parent;
+    var sequence = 0;
+    var elementSequence = 0;
+    var hoverTimer = 0;
+    var structureTimer = 0;
+    var geometryTimer = 0;
+    var domTimer = 0;
+    var pendingClickTimer = 0;
+    var zoomAnimationFrame = 0;
+    var zoomGeometryTimer = 0;
+    var lastGeometryOptions = null;
+    var ZOOM_TRANSITION_MS = 300;
+    var lastPostedScrollX;
+    var lastPostedScrollY;
+    var savedTextSelection = null;
+    var knownSelectedComponents = [];
+    var currentMode = config.mode || getQueryValue("sc_mode") || "edit";
+    if (!parentWindow || parentWindow === window) {
+      return;
+    }
+    var parentOrigin = resolveParentOrigin(config);
+    var allowedParentOrigins = normalizeOrigins(
+      config.allowedParentOrigins || config.parentOrigins || [parentOrigin]
+    );
+    if (!parentOrigin || allowedParentOrigins.indexOf(parentOrigin) < 0) {
+      console.warn("[Parhelia bridge] Missing or rejected parent origin.");
+      return;
+    }
+    var capabilities = [
+      "structure",
+      "geometry",
+      "selection",
+      "inlineEditing",
+      "richTextCommands",
+      "captureDom",
+      "refresh",
+      "zoom"
+    ];
+    var runtime = {
+      source: config.source,
+      packageVersion: buildInfo.packageVersion,
+      commit: buildInfo.commit,
+      builtAt: buildInfo.builtAt
+    };
+    window.__PARHELIA_EDITING_BRIDGE_RUNTIME__ = {
+      family,
+      version,
+      capabilities,
+      runtime,
+      emitStructure,
+      emitGeometry,
+      emitDomSnapshot
+    };
+    if (typeof window.requestRefresh !== "function" && shouldInstallIncrementalRefresh()) {
+      window.requestRefresh = requestIncrementalRefresh;
+    }
+    addEventListener("message", handleMessage);
+    addEventListener("pagehide", rememberHostScroll);
+    addEventListener(
+      "scroll",
+      function() {
+        if (scheduleScrollChanged()) {
+          scheduleGeometry();
+        }
+      },
+      true
+    );
+    addEventListener("resize", function() {
+      postEvent("resizeChanged", {
+        viewport: getViewport(),
+        devicePixelRatio: window.devicePixelRatio || 1
+      });
+      scheduleGeometry();
+      scheduleDomSnapshot();
+    });
+    document.addEventListener("selectionchange", emitSelection);
+    document.addEventListener("click", handleInteraction, true);
+    document.addEventListener("dblclick", handleInteraction, true);
+    document.addEventListener("contextmenu", handleInteraction, true);
+    document.addEventListener("keydown", handleInteraction, true);
+    document.addEventListener("wheel", handleWheel, {
+      capture: true,
+      passive: false
+    });
+    document.addEventListener("pointermove", handleHover, true);
+    document.addEventListener("input", handleInput, true);
+    document.addEventListener("focusout", handleFocusOut, true);
+    var observer = new MutationObserver(function() {
+      scheduleStructure();
+      scheduleGeometry();
+      scheduleDomSnapshot();
+    });
+    if (document.documentElement) {
+      observer.observe(document.documentElement, {
+        childList: true,
+        subtree: true,
+        characterData: true,
+        attributes: true,
+        attributeFilter: [
+          "data-component-start",
+          "data-component-end",
+          "data-component-id",
+          "data-component",
+          "data-placeholder-start",
+          "data-placeholder-key",
+          "data-placeholderkey",
+          "data-fieldid",
+          "data-itemid",
+          "data-language",
+          "data-version",
+          "contenteditable",
+          "hidden",
+          "style",
+          "class"
+        ]
+      });
+    }
+    postReady();
+    applyRememberedHostZoom();
+    applyRememberedHostScroll();
+    initFallbackTimer = setTimeout(startOperationalEmission, INIT_FALLBACK_MS);
+    function postReady() {
+      postEvent("ready", {
+        version,
+        hostUrl: location.href,
+        pageId: config.pageId || getQueryValue("sc_itemid") || void 0,
+        mode: config.mode || getQueryValue("sc_mode") || void 0,
+        viewport: getViewport(),
+        scroll: getScroll(),
+        devicePixelRatio: window.devicePixelRatio || 1,
+        capabilities,
+        runtime
+      });
+    }
+    function handleMessage(event) {
+      if (allowedParentOrigins.indexOf(event.origin) < 0) {
+        return;
+      }
+      var message = event.data;
+      if (!isCommand(message)) {
+        return;
+      }
+      logBridgeMessage("parent -> host", message);
+      try {
+        handleCommand(message);
+      } catch (error) {
+        postEvent("renderError", {
+          message: error && error.message ? error.message : String(error),
+          code: "command_failed",
+          details: { command: message.name, requestId: message.requestId }
+        });
+      }
+    }
+    function handleCommand(message) {
+      var payload = message.payload || {};
+      if (message.name === "hello") {
+        postReady();
+        return;
+      }
+      if (message.name === "init") {
+        knownSelectedComponents = payload.selectedComponentIds || [];
+        acknowledgedCapabilities = payload.acknowledgedCapabilities || capabilities;
+        applyEditorMode(payload.mode || currentMode);
+        applySelectionClasses();
+        startOperationalEmission();
+        return;
+      }
+      if (message.name === "refresh") {
+        postEvent("refreshStarted", { revision: payload.revision });
+        if (typeof window.requestRefresh === "function") {
+          var accepted;
+          try {
+            accepted = window.requestRefresh(payload.url);
+          } catch (error) {
+            postEvent("renderError", {
+              message: error && error.message ? error.message : String(error),
+              code: "refresh_failed",
+              details: {
+                requestId: message.requestId,
+                revision: payload.revision
+              }
+            });
+            runRefreshFallback(payload);
+            return;
+          }
+          if (accepted === false) {
+            runRefreshFallback(payload);
+            return;
+          }
+          if (accepted && typeof accepted.then === "function") {
+            accepted.then(
+              function() {
+                completeRefresh(payload);
+              },
+              function(error) {
+                postEvent("renderError", {
+                  message: error && error.message ? error.message : String(error),
+                  code: "refresh_failed",
+                  details: {
+                    requestId: message.requestId,
+                    revision: payload.revision
+                  }
+                });
+                runRefreshFallback(payload);
+              }
+            );
+            return;
+          }
+          completeRefresh(payload);
+          return;
+        }
+        runRefreshFallback(payload);
+        return;
+      }
+      if (message.name === "setSelection") {
+        knownSelectedComponents = payload.componentIds || [];
+        applySelectionClasses();
+        emitGeometry();
+        return;
+      }
+      if (message.name === "scrollIntoView") {
+        var scrollTarget = findTargetElement(payload);
+        if (scrollTarget) {
+          scrollTarget.scrollIntoView({
+            block: payload.block || "center",
+            inline: "nearest",
+            behavior: "smooth"
+          });
+        }
+        return;
+      }
+      if (message.name === "scrollBy") {
+        var scrollX = Number(payload.x) || 0;
+        var scrollY = Number(payload.y) || 0;
+        var scrollTarget = document.scrollingElement || document.documentElement || document.body;
+        var currentX = window.scrollX || scrollTarget && scrollTarget.scrollLeft || 0;
+        var currentY = window.scrollY || scrollTarget && scrollTarget.scrollTop || 0;
+        var scrollOptions = {
+          left: currentX + scrollX,
+          top: currentY + scrollY,
+          behavior: payload.behavior === "smooth" ? "smooth" : "auto"
+        };
+        try {
+          if (scrollTarget && typeof scrollTarget.scrollTo === "function") {
+            scrollTarget.scrollTo(scrollOptions);
+          } else {
+            window.scrollTo(scrollOptions);
+          }
+        } catch (error) {
+          window.scrollBy(scrollX, scrollY);
+          if (scrollTarget) {
+            scrollTarget.scrollLeft = currentX + scrollX;
+            scrollTarget.scrollTop = currentY + scrollY;
+          }
+        }
+        return;
+      }
+      if (message.name === "queryGeometry") {
+        rememberGeometryOptions(payload);
+        emitGeometry(message.requestId, payload);
+        return;
+      }
+      if (message.name === "beginInlineEdit") {
+        var editable = getInlineEditableElement(payload);
+        if (editable) {
+          beginInlineEdit(editable, payload);
+        }
+        return;
+      }
+      if (message.name === "applyFieldPatch") {
+        var patchTarget = getInlineEditableElement(payload);
+        if (patchTarget) {
+          if (payload.isRichText) {
+            patchTarget.innerHTML = payload.value || "";
+          } else {
+            patchTarget.textContent = payload.value || "";
+          }
+          scheduleStructure();
+          scheduleGeometry();
+          scheduleDomSnapshot();
+        }
+        return;
+      }
+      if (message.name === "applyRichTextCommand") {
+        var richTextTarget = getInlineEditableElement(payload);
+        if (richTextTarget) {
+          var shouldRestoreEditableState = !richTextTarget.isContentEditable;
+          if (shouldRestoreEditableState) {
+            rememberInlineEditableState(richTextTarget);
+            richTextTarget.setAttribute("contenteditable", "true");
+          }
+          if (!restoreSavedTextSelection(richTextTarget, payload)) {
+            richTextTarget.focus();
+          }
+          applyRichTextCommand(payload);
+          emitFieldValueChanged(richTextTarget);
+          emitSelection();
+          if (shouldRestoreEditableState) {
+            restoreInlineEditableState(richTextTarget);
+          }
+        }
+        return;
+      }
+      if (message.name === "commitInlineEdit") {
+        var commitTarget = getInlineEditableElement(payload);
+        if (commitTarget) {
+          emitFieldValueChanged(commitTarget);
+          emitInlineEditEnded(commitTarget, "commit");
+          restoreInlineEditableState(commitTarget);
+        }
+        return;
+      }
+      if (message.name === "cancelInlineEdit") {
+        var cancelTarget = getInlineEditableElement(payload);
+        if (cancelTarget) {
+          emitInlineEditEnded(cancelTarget, "cancel");
+          restoreInlineEditableState(cancelTarget);
+          cancelTarget.blur();
+        }
+        return;
+      }
+      if (message.name === "setPreviewMode") {
+        applyEditorMode(payload.enabled ? "preview" : "edit");
+        return;
+      }
+      if (message.name === "setEditorMode") {
+        applyEditorMode(payload.mode || "edit");
+        return;
+      }
+      if (message.name === "setChromeVisibility") {
+        document.documentElement.toggleAttribute(
+          "data-parhelia-chrome-hidden",
+          !payload.visible
+        );
+        return;
+      }
+      if (message.name === "setZoom") {
+        rememberHostZoom(payload.zoom);
+        applyHostZoom(payload.zoom);
+        emitGeometry();
+        scheduleGeometry();
+        clearTimeout(zoomGeometryTimer);
+        zoomGeometryTimer = setTimeout(function() {
+          zoomGeometryTimer = 0;
+          emitGeometry();
+          scheduleScrollChanged();
+          scheduleDomSnapshot();
+        }, ZOOM_TRANSITION_MS + 50);
+        scheduleScrollChanged();
+        scheduleDomSnapshot();
+        return;
+      }
+      if (message.name === "captureDom") {
+        var captureTarget = payload.selector ? document.querySelector(payload.selector) : document.documentElement;
+        postEvent("captureDomResult", {
+          requestId: payload.requestId || message.requestId || message.id,
+          html: payload.selector ? captureTarget ? serializeElementForCapture(captureTarget) : "" : serializeDocumentForCapture(),
+          text: payload.includeText && captureTarget ? captureTarget.textContent || "" : void 0
+        });
+        return;
+      }
+    }
+    function applyEditorMode(mode) {
+      currentMode = mode || currentMode || "edit";
+      setEditingEnabled(currentMode !== "preview");
+    }
+    function buildStructure() {
+      var componentMap = {};
+      var placeholderMap = {};
+      var fields = [];
+      var components = [];
+      var placeholders = [];
+      var fieldNodes = Array.prototype.slice.call(
+        document.querySelectorAll("[data-fieldid]")
+      );
+      var componentNodes = Array.prototype.slice.call(
+        document.querySelectorAll(
+          "[data-component-start], [data-component-id], [data-renderingid], [data-rendering-id]"
+        )
+      );
+      var placeholderNodes = Array.prototype.slice.call(
+        document.querySelectorAll(
+          "[data-placeholder-start], [data-placeholder-key], [data-placeholderkey]"
+        )
+      );
+      componentNodes.forEach(function(element) {
+        var id = readAttribute(element, [
+          "data-component-start",
+          "data-component-id",
+          "data-renderingid",
+          "data-rendering-id",
+          "id"
+        ]) || ensureElementKey(element);
+        if (componentMap[id]) return;
+        var measurement = measureComponentMarker(element, id);
+        var component = {
+          id,
+          elementKey: ensureElementKey(
+            measurement ? measurement.element : element
+          ),
+          endElementKey: readEndElementKey(id),
+          name: readAttribute(element, ["data-component", "data-component-name"]),
+          type: readAttribute(element, ["data-component", "data-component-name"]),
+          typeId: readAttribute(element, [
+            "data-renderingid",
+            "data-rendering-id"
+          ]),
+          placeholderKey: readAttribute(element, [
+            "data-placeholder-key",
+            "data-placeholderkey"
+          ]),
+          items: [],
+          placeholders: [],
+          renderedDictionaryKeys: [],
+          editable: readEditable(element),
+          visible: !isElementHidden(element)
+        };
+        componentMap[id] = component;
+        components.push(component);
+      });
+      placeholderNodes.forEach(function(element) {
+        var key = readAttribute(element, [
+          "data-placeholder-start",
+          "data-placeholder-key",
+          "data-placeholderkey",
+          "name",
+          "id"
+        ]) || ensureElementKey(element);
+        if (placeholderMap[key]) return;
+        var placeholder = {
+          key,
+          name: key,
+          elementKey: ensureElementKey(element),
+          componentIds: [],
+          editable: readEditable(element)
+        };
+        placeholderMap[key] = placeholder;
+        placeholders.push(placeholder);
+      });
+      fieldNodes.forEach(function(element) {
+        var fieldId = element.getAttribute("data-fieldid");
+        if (!fieldId) return;
+        var componentElement = findNearestComponentElement(element);
+        var componentId = componentElement ? readAttribute(componentElement, [
+          "data-component-start",
+          "data-component-id",
+          "data-renderingid",
+          "data-rendering-id",
+          "data-itemid",
+          "id"
+        ]) : void 0;
+        fields.push({
+          elementKey: ensureElementKey(element),
+          fieldId,
+          componentId,
+          item: readItemDescriptor(element),
+          isRichText: element.getAttribute("data-is-richtext") === "true" || element.getAttribute("data-is-rich-text") === "true",
+          editable: readEditable(element)
+        });
+        if (componentId && componentMap[componentId]) {
+          componentMap[componentId].items = mergeRenderedField(
+            componentMap[componentId].items,
+            readItemDescriptor(element),
+            fieldId
+          );
+        }
+      });
+      return {
+        editRevision: getQueryValue("edit_rev") || void 0,
+        pageId: config.pageId || getQueryValue("sc_itemid") || void 0,
+        url: location.href,
+        components,
+        placeholders,
+        fields
+      };
+    }
+    function buildPageSkeleton() {
+      var pageItem = readPageItemDescriptor();
+      var root = {
+        id: "page",
+        name: "Page",
+        type: "Page",
+        typeId: "",
+        items: [pageItem],
+        placeholders: [],
+        datasourceItem: pageItem,
+        renderedDictionaryKeys: [],
+        editorFields: {},
+        editable: true
+      };
+      var currentComponent = root;
+      var currentPlaceholder;
+      var componentStack = [];
+      function isComponentContainerElement(element) {
+        return element.hasAttribute("data-component-id") || element.hasAttribute("data-renderingid") || element.hasAttribute("data-rendering-id") || element.hasAttribute("data-component-start") && !isElementHidden(element);
+      }
+      function findOpenComponent(componentId) {
+        if (currentComponent && currentComponent.id === componentId) {
+          return currentComponent;
+        }
+        for (var index = componentStack.length - 1; index >= 0; index--) {
+          if (componentStack[index].component.id === componentId) {
+            return componentStack[index].component;
+          }
+        }
+        return void 0;
+      }
+      function trackComponentElement(component, element) {
+        if (!isComponentContainerElement(element)) return;
+        for (var index = componentStack.length - 1; index >= 0; index--) {
+          if (componentStack[index].component.id === component.id) {
+            componentStack[index].element = element;
+            return;
+          }
+        }
+        componentStack.push({ component, element });
+      }
+      function forgetOpenComponent(componentId) {
+        for (var index = componentStack.length - 1; index >= 0; index--) {
+          if (componentStack[index].component.id === componentId) {
+            componentStack.splice(index, 1);
+            return;
+          }
+        }
+      }
+      function closeOpenComponentsBefore(element) {
+        while (componentStack.length > 0) {
+          var entry = componentStack[componentStack.length - 1];
+          if (entry.element === element || entry.element.contains(element)) {
+            return;
+          }
+          componentStack.pop();
+          currentComponent = entry.component;
+          endComponent(entry.component.id);
+        }
+      }
+      function ensurePlaceholder(parentComponent, key, element) {
+        var existing = parentComponent.placeholders.filter(
+          function(placeholder2) {
+            return placeholder2.key === key;
+          }
+        )[0];
+        if (existing) return existing;
+        var placeholder = {
+          key,
+          name: key.indexOf(parentComponent.id + "_") === 0 ? key.substring(parentComponent.id.length + 1) : key,
+          description: element.getAttribute("data-description") || "",
+          components: [],
+          editable: readEditable(element),
+          __parentComponent: parentComponent
+        };
+        parentComponent.placeholders.push(placeholder);
+        return placeholder;
+      }
+      function findPlaceholderByKey(component, key) {
+        for (var index = 0; index < component.placeholders.length; index++) {
+          var placeholder = component.placeholders[index];
+          if (placeholder.key === key) return placeholder;
+          for (var componentIndex = 0; componentIndex < placeholder.components.length; componentIndex++) {
+            var nested = findPlaceholderByKey(
+              placeholder.components[componentIndex],
+              key
+            );
+            if (nested) return nested;
+          }
+        }
+        return void 0;
+      }
+      function startComponent(componentId, element) {
+        var openComponent = findOpenComponent(componentId);
+        if (openComponent) {
+          trackComponentElement(openComponent, element);
+          return;
+        }
+        if (!currentPlaceholder) {
+          var parentComponent = currentComponent || root;
+          var implicitKey = "implicit_" + (parentComponent.datasourceItem && parentComponent.datasourceItem.id || parentComponent.id);
+          currentPlaceholder = ensurePlaceholder(
+            parentComponent,
+            implicitKey,
+            element
+          );
+        }
+        var datasourceItem = readRenderedItemDescriptor(element, pageItem);
+        var componentType = readAttribute(element, [
+          "data-type",
+          "data-component",
+          "data-component-name"
+        ]) || "";
+        var component = {
+          id: componentId,
+          name: componentType,
+          type: componentType,
+          typeId: readAttribute(element, [
+            "data-typeid",
+            "data-renderingid",
+            "data-rendering-id"
+          ]) || "",
+          parametersTemplateId: element.getAttribute("data-parameters-template-id") || void 0,
+          parameters: element.getAttribute("data-parameters") || void 0,
+          items: datasourceItem ? [datasourceItem] : [],
+          placeholders: [],
+          datasourceItem,
+          renderedDictionaryKeys: [],
+          isShared: element.getAttribute("data-shared-datasource") === "true",
+          hasPersonalization: element.getAttribute("data-has-personalization") === "true",
+          layoutId: element.getAttribute("data-layoutid") || void 0,
+          isSharedLayout: element.getAttribute("data-shared-rendering") === "true",
+          editorFields: {},
+          editable: readEditable(element),
+          visible: !isElementHidden(element),
+          __parentPlaceholder: currentPlaceholder
+        };
+        currentPlaceholder.components.push(component);
+        currentComponent = component;
+        currentPlaceholder = void 0;
+        trackComponentElement(component, element);
+      }
+      function endComponent(componentId) {
+        if (!currentComponent || currentComponent.id !== componentId) {
+          return;
+        }
+        var parentPlaceholder = currentComponent.__parentPlaceholder;
+        currentPlaceholder = parentPlaceholder;
+        currentComponent = parentPlaceholder && parentPlaceholder.key.indexOf("implicit_") === 0 ? parentPlaceholder.__parentComponent : void 0;
+      }
+      function closePlaceholder(placeholderKey) {
+        var closingPlaceholder = currentPlaceholder && currentPlaceholder.key === placeholderKey ? currentPlaceholder : findPlaceholderByKey(root, placeholderKey);
+        if (!closingPlaceholder) return;
+        currentComponent = closingPlaceholder.__parentComponent;
+        if (currentPlaceholder === closingPlaceholder) {
+          currentPlaceholder = void 0;
+        }
+      }
+      function addEditorFields(element) {
+        if (!currentComponent) return;
+        var groupName = element.getAttribute("data-editor-group");
+        if (!groupName) return;
+        var group = currentComponent.editorFields[groupName];
+        if (!group) {
+          group = { addFields: [], removeFields: [] };
+          currentComponent.editorFields[groupName] = group;
+        }
+        group.addFields = group.addFields.concat(
+          splitCsv(element.getAttribute("data-add-fields"))
+        );
+        group.removeFields = group.removeFields.concat(
+          splitCsv(element.getAttribute("data-remove-fields"))
+        );
+      }
+      function addRenderedField(element) {
+        if (!currentComponent || !element.hasAttribute("data-fieldid")) return;
+        var renderedItem = readRenderedItemDescriptor(element, pageItem) || currentComponent.datasourceItem || pageItem;
+        var fieldId = element.getAttribute("data-fieldid");
+        var existingItem = currentComponent.items.filter(function(item) {
+          return item.id === renderedItem.id && item.language === renderedItem.language && item.version === renderedItem.version;
+        })[0];
+        if (!existingItem) {
+          existingItem = {
+            id: renderedItem.id,
+            language: renderedItem.language,
+            version: renderedItem.version,
+            database: renderedItem.database,
+            renderedFieldIds: []
+          };
+          currentComponent.items.push(existingItem);
+        }
+        if (existingItem.renderedFieldIds.indexOf(fieldId) < 0) {
+          existingItem.renderedFieldIds.push(fieldId);
+        }
+      }
+      Array.prototype.slice.call(document.documentElement.querySelectorAll("*")).forEach(function(element) {
+        closeOpenComponentsBefore(element);
+        addEditorFields(element);
+        addRenderedField(element);
+        var placeholderStartId = readAttribute(element, [
+          "data-placeholder-start",
+          "data-placeholder-key",
+          "data-placeholderkey"
+        ]);
+        var placeholderEndId = element.getAttribute("data-placeholder-end");
+        var componentStartId = readAttribute(element, [
+          "data-component-start",
+          "data-component-id",
+          "data-renderingid",
+          "data-rendering-id"
+        ]);
+        var componentEndId = element.getAttribute("data-component-end");
+        var dictionaryKeyStart = element.getAttribute(
+          "data-dictionary-key-start"
+        );
+        if (dictionaryKeyStart && currentComponent) {
+          currentComponent.renderedDictionaryKeys.push(dictionaryKeyStart);
+        }
+        if (placeholderStartId) {
+          var parentComponent = currentComponent || root;
+          currentPlaceholder = ensurePlaceholder(
+            parentComponent,
+            placeholderStartId,
+            element
+          );
+          currentComponent = void 0;
+        }
+        if (componentStartId) {
+          startComponent(componentStartId, element);
+        }
+        if (componentEndId) {
+          endComponent(componentEndId);
+          forgetOpenComponent(componentEndId);
+        }
+        if (placeholderEndId) {
+          closePlaceholder(placeholderEndId);
+        }
+      });
+      return {
+        editRevision: getQueryValue("edit_rev") || "",
+        item: pageItem,
+        rootComponent: stripSkeletonComponent(root)
+      };
+    }
+    function getHostZoom() {
+      var documentElement = document.documentElement;
+      if (!documentElement) return 1;
+      var inlineZoom = Number.parseFloat(documentElement.style.zoom);
+      if (Number.isFinite(inlineZoom) && inlineZoom > 0) return inlineZoom;
+      var computedZoom = Number.parseFloat(
+        window.getComputedStyle(documentElement).zoom
+      );
+      if (Number.isFinite(computedZoom) && computedZoom > 0) return computedZoom;
+      return 1;
+    }
+    function getBridgeGeometryRectScale() {
+      var hostZoom = getHostZoom();
+      if (!Number.isFinite(hostZoom) || hostZoom <= 0) return 1;
+      if (Math.abs(hostZoom - 1) < 1e-3) return 1;
+      if (!document.body) return hostZoom;
+      var probe = document.createElement("div");
+      probe.style.cssText = "position:absolute;left:-10000px;top:-10000px;width:100px;height:1px;visibility:hidden;pointer-events:none;";
+      document.body.appendChild(probe);
+      var measuredWidth = probe.getBoundingClientRect().width;
+      if (probe.parentNode) {
+        probe.parentNode.removeChild(probe);
+      }
+      if (!Number.isFinite(measuredWidth) || measuredWidth <= 0) return hostZoom;
+      var unscaledDelta = Math.abs(measuredWidth - 100);
+      var scaledDelta = Math.abs(measuredWidth - 100 * hostZoom);
+      return unscaledDelta <= scaledDelta ? hostZoom : 1;
+    }
+    function buildGeometry(options) {
+      options = options || {};
+      var targets = [];
+      Array.prototype.slice.call(
+        document.querySelectorAll(
+          "[data-component-start], [data-component-id], [data-renderingid], [data-rendering-id]"
+        )
+      ).forEach(function(element) {
+        var componentId = readAttribute(element, [
+          "data-component-start",
+          "data-component-id",
+          "data-renderingid",
+          "data-rendering-id",
+          "id"
+        ]) || ensureElementKey(element);
+        var measurement = measureComponentMarker(element, componentId);
+        if (!measurement) return;
+        targets.push({
+          kind: "component",
+          key: componentId,
+          elementKey: ensureElementKey(measurement.element),
+          componentId,
+          rect: rectToJson(measurement.rect)
+        });
+      });
+      Array.prototype.slice.call(
+        document.querySelectorAll(
+          "[data-placeholder-start], [data-placeholder-key], [data-placeholderkey]"
+        )
+      ).forEach(function(element) {
+        var placeholderKey = readAttribute(element, [
+          "data-placeholder-start",
+          "data-placeholder-key",
+          "data-placeholderkey",
+          "name",
+          "id"
+        ]) || ensureElementKey(element);
+        var measurement = measurePlaceholderMarker(element);
+        targets.push({
+          kind: "placeholder",
+          key: placeholderKey,
+          elementKey: ensureElementKey(measurement.element || element),
+          placeholderKey,
+          orientation: detectPlaceholderOrientation(element),
+          description: element.getAttribute("data-description") || void 0,
+          rect: rectToJson(measurement.rect)
+        });
+      });
+      Array.prototype.slice.call(document.querySelectorAll("[data-fieldid]")).forEach(function(element) {
+        var fieldId = element.getAttribute("data-fieldid");
+        var elementKey = ensureElementKey(element);
+        targets.push({
+          kind: "field",
+          key: elementKey,
+          elementKey,
+          fieldId: fieldId || void 0,
+          item: readItemDescriptor(element),
+          rect: rectToJson(element.getBoundingClientRect())
+        });
+      });
+      (options.textRanges || []).forEach(function(query) {
+        var fieldElement = findFieldElementForGeometryQuery(query);
+        if (!fieldElement) return;
+        var rects = measureTextRangeClientRects(
+          fieldElement,
+          query.start,
+          query.end
+        );
+        rects.forEach(function(rect, index) {
+          targets.push({
+            kind: "textRange",
+            key: query.key,
+            elementKey: ensureElementKey(fieldElement),
+            fieldId: fieldElement.getAttribute("data-fieldid") || void 0,
+            rect: rectToJson(rect),
+            description: String(index)
+          });
+        });
+      });
+      return {
+        viewport: getViewport(),
+        scroll: getScroll(),
+        devicePixelRatio: window.devicePixelRatio || 1,
+        rectScale: getBridgeGeometryRectScale(),
+        scrollScale: getHostZoom(),
+        targets
+      };
+    }
+    function startOperationalEmission() {
+      if (operationalStarted) return;
+      operationalStarted = true;
+      if (initFallbackTimer) {
+        clearTimeout(initFallbackTimer);
+        initFallbackTimer = 0;
+      }
+      emitStructure();
+      emitGeometry();
+      scheduleDomSnapshot();
+    }
+    function emitStructure() {
+      if (!operationalStarted) return;
+      postEvent("structureUpdated", { structure: buildStructure() });
+      postEvent("pageSkeletonUpdated", { pageSkeleton: buildPageSkeleton() });
+    }
+    function rememberGeometryOptions(options) {
+      if (!options || !Array.isArray(options.textRanges)) return;
+      lastGeometryOptions = {
+        textRanges: options.textRanges.slice()
+      };
+    }
+    function getGeometryOptions(options) {
+      if (options && Array.isArray(options.textRanges)) return options;
+      return lastGeometryOptions || options || void 0;
+    }
+    function emitGeometry(requestId, options) {
+      if (!operationalStarted && !requestId) return;
+      postEvent(
+        "geometryUpdated",
+        { geometry: buildGeometry(getGeometryOptions(options)) },
+        requestId
+      );
+    }
+    function completeRefresh(payload) {
+      setTimeout(function() {
+        emitStructure();
+        emitGeometry();
+        emitDomSnapshot();
+        postEvent("refreshCompleted", {
+          revision: payload.revision,
+          structure: buildStructure(),
+          geometry: buildGeometry()
+        });
+      }, 0);
+    }
+    function runRefreshFallback(payload) {
+      rememberHostScroll();
+      if (payload.url) {
+        location.href = payload.url;
+        return;
+      }
+      location.reload();
+    }
+    function shouldInstallIncrementalRefresh() {
+      if (config.refresh === false || config.refreshStrategy === "none" || config.hostRefresh === "none") {
+        return false;
+      }
+      if (config.refresh === "incremental" || config.refreshStrategy === "incremental-dom" || config.hostRefresh === "incremental-dom") {
+        return true;
+      }
+      return !(config.bridgeUrl || config.parentOrigin || config.editorOrigin || config.allowedParentOrigins || config.parentOrigins);
+    }
+    function requestIncrementalRefresh(url) {
+      var target = normalizeRefreshTarget(url);
+      if (!target || target.origin !== location.origin) {
+        return false;
+      }
+      return fetch(target.href, {
+        credentials: "same-origin",
+        cache: "no-store",
+        headers: {
+          "X-Parhelia-Bridge-Refresh": "1"
+        }
+      }).then(function(response) {
+        if (isLoginRedirect(response)) {
+          location.href = response.url;
+          return;
+        }
+        if (!response.ok) {
+          throw new Error(
+            "Refresh request failed with HTTP " + response.status
+          );
+        }
+        var contentType = response.headers && response.headers.get ? response.headers.get("content-type") || "" : "";
+        if (contentType && contentType.toLowerCase().indexOf("text/html") === -1) {
+          throw new Error("Refresh response was not HTML.");
+        }
+        return response.text().then(function(html) {
+          applyIncrementalRefreshHtml(html, response.url || target.href);
+        });
+      });
+    }
+    function normalizeRefreshTarget(url) {
+      try {
+        var target = new URL(url || location.href, location.href);
+        if (target.protocol !== "http:" && target.protocol !== "https:") {
+          return null;
+        }
+        return target;
+      } catch (error) {
+        return null;
+      }
+    }
+    function isLoginRedirect(response) {
+      if (!response || !response.redirected || !response.url) return false;
+      var redirectUrl = response.url.toLowerCase();
+      return redirectUrl.indexOf("/identity/login") >= 0 || redirectUrl.indexOf("/sitecore/login") >= 0 || redirectUrl.indexOf("returnurl=") >= 0;
+    }
+    function applyIncrementalRefreshHtml(html, url) {
+      var parser = new DOMParser();
+      var nextDocument = parser.parseFromString(html, "text/html");
+      if (!nextDocument || !nextDocument.documentElement) {
+        throw new Error("Refresh response could not be parsed as HTML.");
+      }
+      var scrollX = window.scrollX || 0;
+      var scrollY = window.scrollY || 0;
+      var currentZoom = getHostZoom();
+      if (nextDocument.title !== document.title) {
+        document.title = nextDocument.title;
+      }
+      syncElementAttributes(
+        document.documentElement,
+        nextDocument.documentElement,
+        {
+          preserveStyle: true
+        }
+      );
+      if (document.head && nextDocument.head) {
+        patchElement(document.head, nextDocument.head, {
+          preserveBridgeRuntime: true
+        });
+      }
+      if (document.body && nextDocument.body) {
+        patchElement(document.body, nextDocument.body, {
+          preserveBridgeRuntime: true
+        });
+      } else {
+        patchElement(document.documentElement, nextDocument.documentElement, {
+          preserveBridgeRuntime: true
+        });
+      }
+      updateRefreshUrl(url);
+      applyEditorMode(currentMode);
+      applySelectionClasses();
+      reinitializeHostAfterRefresh();
+      restoreRefreshScroll(scrollX, scrollY);
+      if (Math.abs(currentZoom - 1) >= 1e-3) {
+        if (typeof applyHostZoomInstant === "function") {
+          applyHostZoomInstant(currentZoom);
+        } else {
+          applyHostZoom(currentZoom);
+        }
+      }
+    }
+    function patchElement(currentElement, nextElement, options) {
+      if (!currentElement || !nextElement) return;
+      syncElementAttributes(currentElement, nextElement, options);
+      patchChildren(currentElement, nextElement, options);
+    }
+    function patchChildren(currentParent, nextParent, options) {
+      var currentChild = currentParent.firstChild;
+      var nextChild = nextParent.firstChild;
+      while (nextChild) {
+        var nextSibling = nextChild.nextSibling;
+        var currentMatch = currentChild;
+        if (!currentMatch || !canPatchNode(currentMatch, nextChild)) {
+          currentMatch = findPatchMatch(currentParent, nextChild, currentChild);
+        }
+        if (!currentMatch) {
+          currentParent.insertBefore(
+            importRefreshNode(nextChild),
+            currentChild
+          );
+        } else {
+          if (currentMatch !== currentChild) {
+            currentParent.insertBefore(currentMatch, currentChild);
+          }
+          patchNode(currentMatch, nextChild, options);
+          currentChild = currentMatch.nextSibling;
+        }
+        nextChild = nextSibling;
+      }
+      while (currentChild) {
+        var removeNode = currentChild;
+        currentChild = currentChild.nextSibling;
+        if (options && options.preserveBridgeRuntime && isCurrentBridgeScript(removeNode)) {
+          continue;
+        }
+        currentParent.removeChild(removeNode);
+      }
+    }
+    function patchNode(currentNode, nextNode, options) {
+      if (!canPatchNode(currentNode, nextNode)) {
+        currentNode.parentNode.replaceChild(importRefreshNode(nextNode), currentNode);
+        return;
+      }
+      if (currentNode.nodeType === Node.TEXT_NODE || currentNode.nodeType === Node.COMMENT_NODE) {
+        if (currentNode.nodeValue !== nextNode.nodeValue) {
+          currentNode.nodeValue = nextNode.nodeValue;
+        }
+        return;
+      }
+      if (currentNode.nodeType === Node.ELEMENT_NODE) {
+        patchElement(currentNode, nextNode, options);
+      }
+    }
+    function canPatchNode(currentNode, nextNode) {
+      if (!currentNode || !nextNode) return false;
+      if (currentNode.nodeType !== nextNode.nodeType) return false;
+      if (currentNode.nodeType !== Node.ELEMENT_NODE) {
+        return true;
+      }
+      if (currentNode.tagName !== nextNode.tagName) {
+        return false;
+      }
+      var currentKey = getRefreshPatchKey(currentNode);
+      var nextKey = getRefreshPatchKey(nextNode);
+      return !currentKey || !nextKey || currentKey === nextKey;
+    }
+    function findPatchMatch(parent, nextNode, startNode) {
+      var key = getRefreshPatchKey(nextNode);
+      if (!key) return null;
+      var child = startNode;
+      while (child) {
+        if (getRefreshPatchKey(child) === key && canPatchNode(child, nextNode)) {
+          return child;
+        }
+        child = child.nextSibling;
+      }
+      return null;
+    }
+    function getRefreshPatchKey(node) {
+      if (!node || node.nodeType !== Node.ELEMENT_NODE) return "";
+      var element = node;
+      var componentKey = readAttribute(element, [
+        "data-component-start",
+        "data-component-end",
+        "data-component-id",
+        "data-renderingid",
+        "data-rendering-id"
+      ]);
+      if (componentKey) return element.tagName + ":component:" + componentKey;
+      var placeholderKey = readAttribute(element, [
+        "data-placeholder-start",
+        "data-placeholder-end",
+        "data-placeholder-key",
+        "data-placeholderkey"
+      ]);
+      if (placeholderKey) return element.tagName + ":placeholder:" + placeholderKey;
+      var fieldId = element.getAttribute("data-fieldid");
+      if (fieldId) {
+        return [
+          element.tagName,
+          "field",
+          fieldId,
+          element.getAttribute("data-itemid") || "",
+          element.getAttribute("data-language") || "",
+          element.getAttribute("data-version") || ""
+        ].join(":");
+      }
+      if (element.id) return element.tagName + ":id:" + element.id;
+      var scriptSrc = element.tagName === "SCRIPT" ? element.getAttribute("src") : "";
+      if (scriptSrc) return "SCRIPT:src:" + scriptSrc;
+      return "";
+    }
+    function syncElementAttributes(currentElement, nextElement, options) {
+      if (!currentElement || !nextElement) return;
+      var currentAttributes = Array.prototype.slice.call(
+        currentElement.attributes || []
+      );
+      currentAttributes.forEach(function(attribute) {
+        if (options && options.preserveStyle && currentElement === document.documentElement && attribute.name === "style") {
+          return;
+        }
+        if (attribute.name === "data-parhelia-element-key" && !nextElement.hasAttribute(attribute.name)) {
+          return;
+        }
+        if (!nextElement.hasAttribute(attribute.name)) {
+          currentElement.removeAttribute(attribute.name);
+        }
+      });
+      Array.prototype.slice.call(nextElement.attributes || []).forEach(
+        function(attribute) {
+          if (options && options.preserveStyle && currentElement === document.documentElement && attribute.name === "style") {
+            return;
+          }
+          if (currentElement.getAttribute(attribute.name) !== attribute.value) {
+            currentElement.setAttribute(attribute.name, attribute.value);
+          }
+        }
+      );
+    }
+    function importRefreshNode(node) {
+      return document.importNode(node, true);
+    }
+    function isCurrentBridgeScript(node) {
+      if (!node || node.nodeType !== Node.ELEMENT_NODE) return false;
+      if (node.tagName !== "SCRIPT") return false;
+      return isBridgeFamilyScriptSrc(node.getAttribute("src") || "");
+    }
+    function updateRefreshUrl(url) {
+      if (!url || !history || !history.replaceState) return;
+      try {
+        var nextUrl = new URL(url, location.href);
+        if (nextUrl.origin === location.origin) {
+          history.replaceState(history.state, document.title, nextUrl.href);
+        }
+      } catch (error) {
+      }
+    }
+    function reinitializeHostAfterRefresh() {
+      try {
+        if (window.XA && typeof window.XA.init === "function") {
+          window.XA.init();
+        }
+      } catch (error) {
+      }
+    }
+    function restoreRefreshScroll(x, y) {
+      var targetX = x || 0;
+      var targetY = y || 0;
+      var attempts = 0;
+      function apply() {
+        window.scrollTo(targetX, targetY);
+        attempts += 1;
+        var settled = Math.abs((window.scrollY || 0) - targetY) <= 1 && Math.abs((window.scrollX || 0) - targetX) <= 1;
+        if (!settled && attempts < 10) {
+          requestAnimationFrame(apply);
+          return;
+        }
+        scheduleScrollChanged();
+      }
+      requestAnimationFrame(apply);
+    }
+    function emitDomSnapshot() {
+      if (!operationalStarted) return;
+      postEvent("domUpdated", buildDomSnapshot());
+    }
+    function buildDomSnapshot() {
+      var size = getDocumentSize();
+      return {
+        html: serializeDocumentForMinimap(),
+        url: location.href,
+        viewport: getViewport(),
+        scroll: getScroll(),
+        scrollWidth: size.width,
+        scrollHeight: size.height
+      };
+    }
+    function serializeDocumentForMinimap() {
+      if (!document.documentElement) return "";
+      var clone = document.documentElement.cloneNode(true);
+      bakeMinimapLayoutDimensions(document.documentElement, clone);
+      stripMinimapUnsafeNodes(clone);
+      ensureMinimapBase(clone);
+      injectMinimapConstraints(clone);
+      return "<!doctype html>\n" + clone.outerHTML;
+    }
+    function serializeDocumentForCapture() {
+      if (!document.documentElement) return "";
+      var clone = document.documentElement.cloneNode(true);
+      stripMinimapUnsafeNodes(clone);
+      ensureMinimapBase(clone);
+      return "<!doctype html>\n" + clone.outerHTML;
+    }
+    function serializeElementForCapture(element) {
+      if (!element) return "";
+      var clone = element.cloneNode(true);
+      stripMinimapUnsafeNodes(clone);
+      return clone.outerHTML || "";
+    }
+    function bakeMinimapLayoutDimensions(source, target, insideTextFlow) {
+      if (!source || !target) return;
+      var isTextFlow = isMinimapTextFlowElement(source);
+      var shouldBakeSelf = !insideTextFlow && !isTextFlow;
+      if (shouldBakeSelf && target.style && typeof source.getBoundingClientRect === "function") {
+        var rect = source.getBoundingClientRect();
+        if (rect.width > 0) {
+          target.style.setProperty("width", rect.width + "px", "important");
+        }
+        if (rect.height > 0) {
+          target.style.setProperty("height", rect.height + "px", "important");
+        }
+        var computed = window.getComputedStyle ? window.getComputedStyle(source) : null;
+        if (computed && rect.width > 0 && computed.minWidth && computed.minWidth !== "0px" && computed.minWidth !== "auto") {
+          target.style.setProperty("min-width", rect.width + "px", "important");
+        }
+        if (computed && rect.height > 0 && computed.minHeight && computed.minHeight !== "0px" && computed.minHeight !== "auto") {
+          target.style.setProperty("min-height", rect.height + "px", "important");
+        }
+        if (computed && (computed.position === "absolute" || computed.position === "fixed")) {
+          var parentRect = source.offsetParent && source.offsetParent.getBoundingClientRect ? source.offsetParent.getBoundingClientRect() : { left: 0, top: 0 };
+          target.style.setProperty(
+            "left",
+            rect.left - parentRect.left + "px",
+            "important"
+          );
+          target.style.setProperty(
+            "top",
+            rect.top - parentRect.top + "px",
+            "important"
+          );
+        }
+      }
+      var sourceChildren = Array.prototype.slice.call(source.children || []);
+      var targetChildren = Array.prototype.slice.call(target.children || []);
+      var childInsideTextFlow = insideTextFlow || isTextFlow;
+      for (var index = 0; index < sourceChildren.length && index < targetChildren.length; index += 1) {
+        bakeMinimapLayoutDimensions(
+          sourceChildren[index],
+          targetChildren[index],
+          childInsideTextFlow
+        );
+      }
+    }
+    function isMinimapTextFlowElement(element) {
+      if (!element || typeof element.matches !== "function") return false;
+      return element.matches(
+        "[data-fieldid], [contenteditable], input, textarea"
+      );
+    }
+    function stripMinimapUnsafeNodes(root) {
+      Array.prototype.slice.call(root.querySelectorAll("script")).forEach(function(node) {
+        if (node.parentNode) node.parentNode.removeChild(node);
+      });
+      Array.prototype.slice.call(root.querySelectorAll("[contenteditable]")).forEach(function(node) {
+        node.removeAttribute("contenteditable");
+        node.removeAttribute("data-parhelia-inline-editing");
+      });
+      if (root.hasAttribute && root.hasAttribute("contenteditable")) {
+        root.removeAttribute("contenteditable");
+        root.removeAttribute("data-parhelia-inline-editing");
+      }
+      [root].concat(Array.prototype.slice.call(root.querySelectorAll("*"))).forEach(function(node) {
+        Array.prototype.slice.call(node.attributes || []).forEach(function(attribute) {
+          var name = attribute.name.toLowerCase();
+          var value = String(attribute.value || "");
+          var isScriptAttribute = name.indexOf("on") === 0 || name === "srcdoc" || (name === "href" || name === "src" || name === "xlink:href" || name === "formaction") && /^\s*javascript:/i.test(value);
+          if (isScriptAttribute) {
+            node.removeAttribute(attribute.name);
+          }
+        });
+      });
+    }
+    function ensureMinimapBase(root) {
+      var head = root.querySelector("head");
+      if (!head) return;
+      Array.prototype.slice.call(head.querySelectorAll("base")).forEach(function(node) {
+        node.parentNode.removeChild(node);
+      });
+      var base = document.createElement("base");
+      base.setAttribute("href", location.href);
+      head.insertBefore(base, head.firstChild);
+    }
+    function injectMinimapConstraints(root) {
+      var head = root.querySelector("head");
+      if (!head) return;
+      var style = document.createElement("style");
+      style.setAttribute("data-parhelia-minimap-constraints", "true");
+      style.textContent = [
+        "html, body { overflow: hidden !important; }",
+        "body { pointer-events: none !important; }",
+        "script { display: none !important; }",
+        "video, img, picture, iframe { max-width: 100% !important; height: auto !important; }"
+      ].join("\n");
+      head.appendChild(style);
+    }
+    function emitSelection() {
+      var selection = document.getSelection();
+      if (!selection || selection.rangeCount === 0) {
+        postEvent("selectionChanged", {
+          selection: { collapsed: true }
+        });
+        return;
+      }
+      if (!selection.isCollapsed && selection.toString().trim()) {
+        clearPendingClickInteraction();
+      }
+      var range = selection.getRangeAt(0);
+      var fieldElement = closestFieldElement(
+        range.startContainer.nodeType === Node.ELEMENT_NODE ? range.startContainer : range.startContainer.parentElement
+      );
+      var startOffset = fieldElement ? getTextOffset(fieldElement, range.startContainer, range.startOffset) : range.startOffset;
+      var endOffset = fieldElement ? getTextOffset(fieldElement, range.endContainer, range.endOffset) : range.endOffset;
+      var context = fieldElement ? getSelectionContext(fieldElement, startOffset, endOffset) : void 0;
+      var selectionRect = getSelectionRect(range);
+      var activeField = fieldElement ? {
+        elementKey: ensureElementKey(fieldElement),
+        fieldId: fieldElement.getAttribute("data-fieldid") || "",
+        item: readItemDescriptor(fieldElement),
+        isRichText: fieldElement.getAttribute("data-is-richtext") === "true" || fieldElement.getAttribute("data-is-rich-text") === "true"
+      } : void 0;
+      if (activeField && !selection.isCollapsed) {
+        try {
+          savedTextSelection = {
+            elementKey: activeField.elementKey,
+            fieldId: activeField.fieldId,
+            range: range.cloneRange()
+          };
+        } catch (error) {
+          savedTextSelection = null;
+        }
+      }
+      postEvent("selectionChanged", {
+        selection: {
+          activeField,
+          collapsed: selection.isCollapsed,
+          rect: selectionRect ? rectToJson(selectionRect) : void 0,
+          startOffset,
+          endOffset,
+          text: selection.toString(),
+          metadata: context
+        }
+      });
+    }
+    function clearPendingClickInteraction() {
+      if (!pendingClickTimer) return;
+      clearTimeout(pendingClickTimer);
+      pendingClickTimer = 0;
+    }
+    function hasActiveTextSelection(fieldElement) {
+      var selection = document.getSelection();
+      if (!selection || selection.rangeCount === 0 || selection.isCollapsed || !selection.toString().trim()) {
+        return false;
+      }
+      if (!fieldElement) return true;
+      try {
+        var range = selection.getRangeAt(0);
+        var container = range.commonAncestorContainer;
+        var element = container.nodeType === Node.ELEMENT_NODE ? container : container.parentElement;
+        return !!element && fieldElement.contains(element);
+      } catch (error) {
+        return true;
+      }
+    }
+    function handleInteraction(event) {
+      var target = event.target && event.target.nodeType === Node.ELEMENT_NODE ? event.target : event.target && event.target.parentElement;
+      if (!target) return;
+      var fieldElement = closestFieldElement(target);
+      var componentElement = findNearestComponentElement(target);
+      var placeholderElement = closestPlaceholderElement(target);
+      var kind = event.type === "dblclick" ? "doubleClick" : event.type === "contextmenu" ? "contextMenu" : event.type === "keydown" ? "keydown" : "click";
+      var anchor = target.tagName && target.tagName.toLowerCase() === "a" ? target : target.closest ? target.closest("a") : null;
+      if (kind === "click" && anchor && currentMode !== "preview" && currentMode !== "suggestions") {
+        event.preventDefault();
+      }
+      if (kind === "contextMenu" && !event.ctrlKey) {
+        event.preventDefault();
+      }
+      if (kind === "doubleClick") {
+        clearPendingClickInteraction();
+        emitSelection();
+        return;
+      }
+      if (kind === "click" && fieldElement && hasActiveTextSelection(fieldElement)) {
+        clearPendingClickInteraction();
+        emitSelection();
+        return;
+      }
+      var payload = {
+        kind,
+        elementKey: fieldElement ? ensureElementKey(fieldElement) : ensureElementKey(target),
+        componentId: componentElement ? readAttribute(componentElement, [
+          "data-component-start",
+          "data-component-id",
+          "data-renderingid",
+          "data-rendering-id",
+          "id"
+        ]) : void 0,
+        fieldId: fieldElement ? fieldElement.getAttribute("data-fieldid") : void 0,
+        item: fieldElement ? readItemDescriptor(fieldElement) : void 0,
+        placeholderKey: placeholderElement ? readAttribute(placeholderElement, [
+          "data-placeholder-start",
+          "data-placeholder-key",
+          "data-placeholderkey",
+          "name",
+          "id"
+        ]) : void 0,
+        clientX: event.clientX,
+        clientY: event.clientY,
+        key: event.key,
+        code: event.code,
+        button: event.button,
+        ctrlKey: !!event.ctrlKey,
+        shiftKey: !!event.shiftKey,
+        altKey: !!event.altKey,
+        metaKey: !!event.metaKey
+      };
+      if (kind === "click" && fieldElement) {
+        if (componentElement || event.ctrlKey || event.shiftKey || event.metaKey) {
+          postEvent("interaction", payload);
+          return;
+        }
+        clearPendingClickInteraction();
+        pendingClickTimer = setTimeout(function() {
+          pendingClickTimer = 0;
+          if (hasActiveTextSelection(fieldElement)) {
+            emitSelection();
+            return;
+          }
+          postEvent("interaction", payload);
+        }, 220);
+        return;
+      }
+      postEvent("interaction", payload);
+    }
+    function handleWheel(event) {
+      if (!event.ctrlKey && !event.metaKey) return;
+      if (event.deltaY === 0) return;
+      event.preventDefault();
+      event.stopPropagation();
+      var target = event.target && event.target.nodeType === Node.ELEMENT_NODE ? event.target : event.target && event.target.parentElement;
+      if (!target) return;
+      var fieldElement = closestFieldElement(target);
+      var componentElement = findNearestComponentElement(target);
+      var placeholderElement = closestPlaceholderElement(target);
+      postEvent("interaction", {
+        kind: "wheel",
+        elementKey: fieldElement ? ensureElementKey(fieldElement) : ensureElementKey(target),
+        componentId: componentElement ? readAttribute(componentElement, [
+          "data-component-start",
+          "data-component-id",
+          "data-renderingid",
+          "data-rendering-id",
+          "id"
+        ]) : void 0,
+        fieldId: fieldElement ? fieldElement.getAttribute("data-fieldid") : void 0,
+        item: fieldElement ? readItemDescriptor(fieldElement) : void 0,
+        placeholderKey: placeholderElement ? readAttribute(placeholderElement, [
+          "data-placeholder-start",
+          "data-placeholder-key",
+          "data-placeholderkey",
+          "name",
+          "id"
+        ]) : void 0,
+        clientX: event.clientX,
+        clientY: event.clientY,
+        deltaX: event.deltaX,
+        deltaY: event.deltaY,
+        ctrlKey: !!event.ctrlKey,
+        shiftKey: !!event.shiftKey,
+        altKey: !!event.altKey,
+        metaKey: !!event.metaKey
+      });
+    }
+    function handleHover(event) {
+      clearTimeout(hoverTimer);
+      hoverTimer = setTimeout(function() {
+        var target = event.target && event.target.nodeType === Node.ELEMENT_NODE ? event.target : event.target && event.target.parentElement;
+        if (!target) return;
+        var mediaElement = closestMediaElement(target);
+        var fieldElement = closestFieldElement(target) || (mediaElement ? closestFieldElement(mediaElement) : null);
+        var componentElement = findNearestComponentElement(target);
+        var placeholderElement = closestPlaceholderElement(target);
+        var currentMediaSource = mediaElement ? getCurrentPictureSource(mediaElement) : null;
+        postEvent("interaction", {
+          kind: "hover",
+          elementKey: ensureElementKey(fieldElement || mediaElement || target),
+          componentId: componentElement ? readAttribute(componentElement, [
+            "data-component-start",
+            "data-component-id",
+            "data-renderingid",
+            "data-rendering-id",
+            "id"
+          ]) : void 0,
+          fieldId: fieldElement ? fieldElement.getAttribute("data-fieldid") : void 0,
+          item: fieldElement ? readItemDescriptor(fieldElement) : void 0,
+          media: mediaElement ? {
+            elementKey: ensureElementKey(mediaElement),
+            tagName: mediaElement.tagName ? mediaElement.tagName.toLowerCase() : "",
+            variantName: currentMediaSource && currentMediaSource.getAttribute("data-variant") || mediaElement.getAttribute("data-variant") || void 0
+          } : void 0,
+          placeholderKey: placeholderElement ? readAttribute(placeholderElement, [
+            "data-placeholder-start",
+            "data-placeholder-key",
+            "data-placeholderkey",
+            "name",
+            "id"
+          ]) : void 0,
+          clientX: event.clientX,
+          clientY: event.clientY
+        });
+      }, 100);
+    }
+    function handleInput(event) {
+      var target = event.target && event.target.nodeType === Node.ELEMENT_NODE ? event.target : void 0;
+      if (!target) return;
+      var fieldElement = closestFieldElement(target);
+      if (fieldElement) {
+        emitFieldValueChanged(fieldElement);
+        scheduleDomSnapshot();
+      }
+    }
+    function handleFocusOut(event) {
+      var target = event.target && event.target.nodeType === Node.ELEMENT_NODE ? event.target : event.target && event.target.parentElement;
+      if (!target) return;
+      var fieldElement = closestFieldElement(target);
+      if (!fieldElement) return;
+      if (fieldElement.getAttribute("data-parhelia-inline-editing") !== "true") {
+        return;
+      }
+      var relatedTarget = event.relatedTarget;
+      if (relatedTarget && fieldElement.contains(relatedTarget)) return;
+      emitFieldValueChanged(fieldElement);
+      emitInlineEditEnded(fieldElement, "blur");
+      restoreInlineEditableState(fieldElement);
+    }
+    function emitFieldValueChanged(element) {
+      var isRichText = element.getAttribute("data-is-richtext") === "true" || element.getAttribute("data-is-rich-text") === "true";
+      postEvent("fieldValueChanged", {
+        elementKey: ensureElementKey(element),
+        fieldId: element.getAttribute("data-fieldid") || "",
+        item: readItemDescriptor(element),
+        value: getFieldValue(element, isRichText),
+        isRichText
+      });
+    }
+    function emitInlineEditEnded(element, reason) {
+      var isRichText = element.getAttribute("data-is-richtext") === "true" || element.getAttribute("data-is-rich-text") === "true";
+      postEvent("inlineEditEnded", {
+        elementKey: ensureElementKey(element),
+        fieldId: element.getAttribute("data-fieldid") || "",
+        item: readItemDescriptor(element),
+        value: getFieldValue(element, isRichText),
+        isRichText,
+        reason
+      });
+    }
+    function postEvent(name, payload, requestId) {
+      var message = {
+        family,
+        version,
+        direction: "host-to-parent",
+        id: "host-" + Date.now().toString(36) + "-" + sequence++,
+        name,
+        timestamp: Date.now(),
+        requestId,
+        payload: payload || {}
+      };
+      logBridgeMessage("host -> parent", message);
+      parentWindow.postMessage(message, parentOrigin);
+    }
+    function isCommand(message) {
+      return message && typeof message === "object" && message.family === family && message.version && typeof message.version.major === "number" && message.version.major === version.major && message.direction === "parent-to-host" && typeof message.name === "string" && typeof message.id === "string";
+    }
+    function scheduleStructure() {
+      clearTimeout(structureTimer);
+      structureTimer = setTimeout(emitStructure, 100);
+    }
+    function scheduleGeometry() {
+      clearTimeout(geometryTimer);
+      geometryTimer = setTimeout(emitGeometry, 50);
+      scheduleScrollChanged();
+    }
+    function scheduleDomSnapshot() {
+      clearTimeout(domTimer);
+      domTimer = setTimeout(emitDomSnapshot, 150);
+    }
+    function scheduleScrollChanged() {
+      var scroll = getScroll();
+      if (scroll.x === lastPostedScrollX && scroll.y === lastPostedScrollY) {
+        return false;
+      }
+      lastPostedScrollX = scroll.x;
+      lastPostedScrollY = scroll.y;
+      postEvent("scrollChanged", { scroll });
+      return true;
+    }
+    function getViewport() {
+      return {
+        width: window.innerWidth || document.documentElement.clientWidth || 0,
+        height: window.innerHeight || document.documentElement.clientHeight || 0
+      };
+    }
+    function getScroll() {
+      var scrollingElement = document.scrollingElement;
+      var documentElement = document.documentElement;
+      var body = document.body;
+      return {
+        x: Math.max(
+          window.scrollX || 0,
+          scrollingElement ? scrollingElement.scrollLeft || 0 : 0,
+          documentElement ? documentElement.scrollLeft || 0 : 0,
+          body ? body.scrollLeft || 0 : 0
+        ),
+        y: Math.max(
+          window.scrollY || 0,
+          scrollingElement ? scrollingElement.scrollTop || 0 : 0,
+          documentElement ? documentElement.scrollTop || 0 : 0,
+          body ? body.scrollTop || 0 : 0
+        )
+      };
+    }
+    function getDocumentSize() {
+      var documentElement = document.documentElement;
+      var body = document.body;
+      return {
+        width: Math.max(
+          window.innerWidth || 0,
+          documentElement ? documentElement.clientWidth || 0 : 0,
+          documentElement ? documentElement.scrollWidth || 0 : 0,
+          body ? body.scrollWidth || 0 : 0
+        ),
+        height: Math.max(
+          window.innerHeight || 0,
+          documentElement ? documentElement.clientHeight || 0 : 0,
+          documentElement ? documentElement.scrollHeight || 0 : 0,
+          body ? body.scrollHeight || 0 : 0
+        )
+      };
+    }
+    function getQueryValue(name) {
+      return new URLSearchParams(location.search).get(name);
+    }
+    function rectToJson(rect) {
+      return {
+        x: rect.x,
+        y: rect.y,
+        width: rect.width,
+        height: rect.height,
+        top: rect.top,
+        right: rect.right,
+        bottom: rect.bottom,
+        left: rect.left
+      };
+    }
+    function measureComponentMarker(marker, componentId) {
+      var endMarker = componentId ? document.querySelector(
+        '[data-component-end="' + cssEscape(componentId) + '"]'
+      ) : null;
+      var elements = collectComponentElements(marker, endMarker);
+      var rect = unionElementRects(elements);
+      if (rect) {
+        return {
+          element: elements[0],
+          rect
+        };
+      }
+      if (!isChromeMarkerElement(marker)) {
+        var markerRect = marker.getBoundingClientRect();
+        if (hasVisibleRect(markerRect)) {
+          return {
+            element: marker,
+            rect: markerRect
+          };
+        }
+      }
+      return null;
+    }
+    function measurePlaceholderMarker(marker) {
+      var markerRect = marker.getBoundingClientRect();
+      if (!isChromeMarkerElement(marker) && hasVisibleRect(markerRect)) {
+        return {
+          element: marker,
+          rect: markerRect
+        };
+      }
+      var previous = getPreviousContentElement(marker);
+      if (previous) {
+        return {
+          element: previous,
+          rect: previous.getBoundingClientRect()
+        };
+      }
+      var next = getNextContentElement(marker);
+      if (next) {
+        return {
+          element: next,
+          rect: next.getBoundingClientRect()
+        };
+      }
+      var parent = marker.parentElement;
+      if (parent) {
+        return {
+          element: parent,
+          rect: parent.getBoundingClientRect()
+        };
+      }
+      return {
+        element: marker,
+        rect: markerRect
+      };
+    }
+    function getPreviousContentElement(element) {
+      var current = element.previousElementSibling;
+      while (current) {
+        if (!isChromeMarkerElement(current) && !isElementHidden(current)) {
+          return current;
+        }
+        current = current.previousElementSibling;
+      }
+      return null;
+    }
+    function getNextContentElement(element) {
+      var current = element.nextElementSibling;
+      while (current) {
+        if (!isChromeMarkerElement(current) && !isElementHidden(current)) {
+          return current;
+        }
+        current = current.nextElementSibling;
+      }
+      return null;
+    }
+    function detectPlaceholderOrientation(marker) {
+      var explicit = marker.getAttribute("data-orientation");
+      if (explicit === "horizontal" || explicit === "vertical") return explicit;
+      var parent = marker.parentElement;
+      if (!parent) return "vertical";
+      var style = getComputedStyle(parent);
+      var display = style.getPropertyValue("display");
+      if (display === "flex" || display === "inline-flex") {
+        var flexDirection = style.getPropertyValue("flex-direction");
+        if (flexDirection === "row" || flexDirection === "row-reverse") {
+          return "horizontal";
+        }
+        if (flexDirection === "column" || flexDirection === "column-reverse") {
+          return "vertical";
+        }
+      }
+      if (display === "grid" || display === "inline-grid") {
+        var gridAutoFlow = style.getPropertyValue("grid-auto-flow");
+        if (gridAutoFlow.indexOf("column") >= 0) return "horizontal";
+        if (gridAutoFlow.indexOf("row") >= 0) return "vertical";
+      }
+      var previous = getPreviousContentElement(marker);
+      var next = getNextContentElement(marker);
+      if (previous && next) {
+        var previousRect = previous.getBoundingClientRect();
+        var nextRect = next.getBoundingClientRect();
+        var horizontalDiff = Math.abs(nextRect.x - previousRect.x);
+        var verticalDiff = Math.abs(nextRect.y - previousRect.y);
+        return horizontalDiff > verticalDiff ? "horizontal" : "vertical";
+      }
+      return "vertical";
+    }
+    function collectComponentElements(marker, endMarker) {
+      if (!marker) return [];
+      if (!isChromeMarkerElement(marker)) {
+        return [marker];
+      }
+      var elements = [];
+      var current = marker.nextElementSibling;
+      var safety = 0;
+      while (current && current !== endMarker && safety++ < 1e3) {
+        if (!isChromeMarkerElement(current) && !isElementHidden(current)) {
+          elements.push(current);
+        }
+        if (!endMarker) break;
+        current = current.nextElementSibling;
+      }
+      return elements;
+    }
+    function unionElementRects(elements) {
+      var left = Infinity;
+      var top = Infinity;
+      var right = -Infinity;
+      var bottom = -Infinity;
+      var hasRect = false;
+      elements.forEach(function(element) {
+        var rect = element.getBoundingClientRect();
+        if (!hasVisibleRect(rect)) return;
+        left = Math.min(left, rect.left);
+        top = Math.min(top, rect.top);
+        right = Math.max(right, rect.right);
+        bottom = Math.max(bottom, rect.bottom);
+        hasRect = true;
+      });
+      if (!hasRect) return null;
+      return {
+        x: left,
+        y: top,
+        left,
+        top,
+        right,
+        bottom,
+        width: right - left,
+        height: bottom - top
+      };
+    }
+    function hasVisibleRect(rect) {
+      return !!rect && (rect.width > 0 || rect.height > 0);
+    }
+    function isChromeMarkerElement(element) {
+      if (!element || !element.tagName) return false;
+      return element.tagName === "SCRIPT" || element.tagName === "CODE" && element.getAttribute("type") === "text/sitecore" && element.hasAttribute("chrometype");
+    }
+    function ensureElementKey(element) {
+      if (!element || !element.getAttribute) {
+        return "";
+      }
+      var existing = element.getAttribute("data-parhelia-element-key");
+      if (existing) return existing;
+      var next = "el-" + ++elementSequence;
+      element.setAttribute("data-parhelia-element-key", next);
+      return next;
+    }
+    function getElementByKey(key) {
+      if (!key) return null;
+      return document.querySelector(
+        '[data-parhelia-element-key="' + cssEscape(key) + '"]'
+      );
+    }
+    function getInlineEditableElement(payload) {
+      var target = payload.elementKey ? getElementByKey(payload.elementKey) : null;
+      var fieldElement = target ? closestFieldElement(target) : null;
+      if (!fieldElement && target && target.getAttribute("data-fieldid")) {
+        fieldElement = target;
+      }
+      if (fieldElement && payload.fieldId && fieldElement.getAttribute("data-fieldid") !== payload.fieldId) {
+        fieldElement = null;
+      }
+      if (!fieldElement && payload.fieldId) {
+        fieldElement = document.querySelector(
+          '[data-fieldid="' + cssEscape(payload.fieldId) + '"]'
+        );
+      }
+      return fieldElement;
+    }
+    function beginInlineEdit(element, payload) {
+      if (currentMode === "preview") return;
+      var selectedRange = getSelectionRangeWithin(element);
+      rememberInlineEditableState(element);
+      element.setAttribute("contenteditable", "true");
+      element.setAttribute("data-parhelia-inline-editing", "true");
+      if (selectedRange) {
+        restoreSelectionRange(element, selectedRange);
+      } else {
+        focusEditableElement(element, payload.clientX, payload.clientY);
+      }
+      emitSelection();
+      emitGeometry();
+    }
+    function getSelectionRangeWithin(element) {
+      var selection = document.getSelection();
+      if (!selection || selection.rangeCount === 0) {
+        return null;
+      }
+      try {
+        var range = selection.getRangeAt(0);
+        var ancestor = range.commonAncestorContainer;
+        var ancestorElement = ancestor.nodeType === Node.ELEMENT_NODE ? ancestor : ancestor.parentElement;
+        if (!ancestorElement || !element.contains(ancestorElement)) {
+          return null;
+        }
+        return range.cloneRange();
+      } catch (error) {
+        return null;
+      }
+    }
+    function rememberInlineEditableState(element) {
+      if (element.hasAttribute("data-parhelia-previous-contenteditable")) return;
+      element.setAttribute(
+        "data-parhelia-previous-contenteditable",
+        element.hasAttribute("contenteditable") ? element.getAttribute("contenteditable") || "" : "__missing__"
+      );
+    }
+    function restoreInlineEditableState(element) {
+      var previous = element.getAttribute(
+        "data-parhelia-previous-contenteditable"
+      );
+      if (previous === "__missing__" || previous === null) {
+        element.removeAttribute("contenteditable");
+      } else {
+        element.setAttribute("contenteditable", previous);
+      }
+      element.removeAttribute("data-parhelia-previous-contenteditable");
+      element.removeAttribute("data-parhelia-inline-editing");
+      emitGeometry();
+    }
+    function focusEditableElement(element, clientX, clientY) {
+      try {
+        element.focus({ preventScroll: true });
+      } catch (error) {
+        element.focus();
+      }
+      var range = createRangeFromPoint(clientX, clientY);
+      if (!range || !element.contains(range.startContainer)) return;
+      var selection = document.getSelection();
+      if (!selection) return;
+      selection.removeAllRanges();
+      selection.addRange(range);
+    }
+    function restoreSelectionRange(element, range) {
+      try {
+        element.focus({ preventScroll: true });
+      } catch (error) {
+        element.focus();
+      }
+      var selection = document.getSelection();
+      if (!selection) return;
+      selection.removeAllRanges();
+      selection.addRange(range);
+    }
+    function restoreSavedTextSelection(element, payload) {
+      if (!savedTextSelection) return false;
+      if (payload.elementKey && savedTextSelection.elementKey !== payload.elementKey) {
+        return false;
+      }
+      if (payload.fieldId && savedTextSelection.fieldId !== payload.fieldId) {
+        return false;
+      }
+      try {
+        var selection = document.getSelection();
+        if (!selection) return false;
+        element.focus({ preventScroll: true });
+        selection.removeAllRanges();
+        selection.addRange(savedTextSelection.range.cloneRange());
+        return true;
+      } catch (error) {
+        return false;
+      }
+    }
+    function applyRichTextCommand(payload) {
+      if (payload.command === "createLink") {
+        insertLinkAtCurrentSelection(payload.value || "#");
+        return;
+      }
+      document.execCommand(payload.command, false, payload.value);
+    }
+    function insertLinkAtCurrentSelection(href) {
+      var selection = document.getSelection();
+      if (!selection || selection.rangeCount === 0) {
+        document.execCommand("createLink", false, href);
+        return;
+      }
+      var range = selection.getRangeAt(0);
+      var link = document.createElement("a");
+      link.href = href;
+      link.textContent = href;
+      range.deleteContents();
+      range.insertNode(link);
+      var afterLinkRange = document.createRange();
+      afterLinkRange.setStartAfter(link);
+      afterLinkRange.collapse(true);
+      selection.removeAllRanges();
+      selection.addRange(afterLinkRange);
+    }
+    function createRangeFromPoint(clientX, clientY) {
+      if (typeof clientX !== "number" || typeof clientY !== "number") return null;
+      if (typeof document.caretRangeFromPoint === "function") {
+        return document.caretRangeFromPoint(clientX, clientY);
+      }
+      if (typeof document.caretPositionFromPoint === "function") {
+        var position = document.caretPositionFromPoint(clientX, clientY);
+        if (!position) return null;
+        var range = document.createRange();
+        range.setStart(position.offsetNode, position.offset);
+        range.collapse(true);
+        return range;
+      }
+      return null;
+    }
+    function getFieldValue(element, isRichText) {
+      var value = isRichText ? element.innerHTML : element.textContent || "";
+      return value.replace(/\u200B/g, "");
+    }
+    function findTargetElement(payload) {
+      if (payload.elementKey) return getElementByKey(payload.elementKey);
+      if (payload.componentId) {
+        return document.querySelector(
+          '[data-component-start="' + cssEscape(payload.componentId) + '"], [data-component-id="' + cssEscape(payload.componentId) + '"], [data-renderingid="' + cssEscape(payload.componentId) + '"], [data-rendering-id="' + cssEscape(payload.componentId) + '"]'
+        );
+      }
+      if (payload.fieldId) {
+        return document.querySelector(
+          '[data-fieldid="' + cssEscape(payload.fieldId) + '"]'
+        );
+      }
+      if (payload.placeholderKey) {
+        return document.querySelector(
+          '[data-placeholder-start="' + cssEscape(payload.placeholderKey) + '"], [data-placeholder-key="' + cssEscape(payload.placeholderKey) + '"], [data-placeholderkey="' + cssEscape(payload.placeholderKey) + '"]'
+        );
+      }
+      return null;
+    }
+    function findFieldElementForGeometryQuery(query) {
+      if (query.elementKey) {
+        var element = getElementByKey(query.elementKey);
+        if (element && element.hasAttribute("data-fieldid")) return element;
+      }
+      if (!query.fieldId) return null;
+      var candidates = Array.prototype.slice.call(
+        document.querySelectorAll(
+          '[data-fieldid="' + cssEscape(query.fieldId) + '"]'
+        )
+      );
+      if (!query.item || !query.item.id) return candidates[0] || null;
+      return candidates.filter(function(element2) {
+        return itemDescriptorMatches(readItemDescriptor(element2), query.item);
+      })[0] || candidates[0] || null;
+    }
+    function itemDescriptorMatches(left, right) {
+      if (!left || !right) return false;
+      if (!idsMatch(left.id, right.id)) return false;
+      if (right.language && left.language && left.language !== right.language) {
+        return false;
+      }
+      if (right.version !== void 0 && left.version !== void 0 && left.version !== right.version) {
+        return false;
+      }
+      return true;
+    }
+    function idsMatch(left, right) {
+      return normalizeId(left) === normalizeId(right);
+    }
+    function normalizeId(value) {
+      return String(value || "").replace(/[{}]/g, "").toLowerCase();
+    }
+    function readEndElementKey(componentId) {
+      var end = document.querySelector(
+        '[data-component-end="' + cssEscape(componentId) + '"]'
+      );
+      return end ? ensureElementKey(end) : void 0;
+    }
+    function readAttribute(element, names) {
+      for (var index = 0; index < names.length; index++) {
+        var value = element.getAttribute(names[index]);
+        if (value) return value;
+      }
+      return void 0;
+    }
+    function readEditable(element) {
+      if (element.getAttribute("data-parhelia-editable") === "false")
+        return false;
+      if (element.getAttribute("data-editable") === "false") return false;
+      return true;
+    }
+    function readItemDescriptor(element) {
+      var id = element.getAttribute("data-itemid");
+      if (!id) return void 0;
+      return {
+        id,
+        language: element.getAttribute("data-language") || void 0,
+        version: toNumber(element.getAttribute("data-version")),
+        database: element.getAttribute("data-database") || void 0
+      };
+    }
+    function readPageItemDescriptor() {
+      return {
+        id: getQueryValue("sc_itemid") || getQueryValue("itemid") || config.pageId || "",
+        language: getQueryValue("sc_lang") || getQueryValue("lang") || "",
+        version: toNumber(getQueryValue("sc_version") || getQueryValue("version")) || 0,
+        database: getQueryValue("sc_database") || getQueryValue("database") || void 0,
+        renderedFieldIds: []
+      };
+    }
+    function readRenderedItemDescriptor(element, fallbackItem) {
+      var item = readItemDescriptor(element);
+      if (!item || !item.id) return void 0;
+      return {
+        id: item.id,
+        language: item.language || fallbackItem.language,
+        version: item.version || fallbackItem.version,
+        database: item.database || fallbackItem.database,
+        renderedFieldIds: []
+      };
+    }
+    function splitCsv(value) {
+      if (!value) return [];
+      return value.split(",").map(function(item) {
+        return item.trim();
+      }).filter(Boolean);
+    }
+    function stripSkeletonComponent(component) {
+      return {
+        id: component.id,
+        name: component.name || "",
+        type: component.type || "",
+        typeId: component.typeId || "",
+        parametersTemplateId: component.parametersTemplateId,
+        parameters: component.parameters,
+        items: component.items,
+        placeholders: component.placeholders.map(stripSkeletonPlaceholder),
+        datasourceItem: component.datasourceItem,
+        visible: component.visible,
+        renderedDictionaryKeys: component.renderedDictionaryKeys || [],
+        isShared: component.isShared,
+        hasPersonalization: component.hasPersonalization,
+        layoutId: component.layoutId,
+        isSharedLayout: component.isSharedLayout,
+        editorFields: component.editorFields || {},
+        editable: component.editable
+      };
+    }
+    function stripSkeletonPlaceholder(placeholder) {
+      return {
+        key: placeholder.key,
+        name: placeholder.name || placeholder.key,
+        description: placeholder.description || "",
+        components: placeholder.components.map(stripSkeletonComponent),
+        editable: placeholder.editable
+      };
+    }
+    function mergeRenderedField(items, item, fieldId) {
+      if (!item || !item.id) return items;
+      if (!fieldId) return items;
+      var existing = items.filter(function(candidate) {
+        return candidate.id === item.id && candidate.language === item.language && candidate.version === item.version;
+      })[0];
+      if (existing) {
+        if (existing.renderedFieldIds.indexOf(fieldId) < 0) {
+          existing.renderedFieldIds.push(fieldId);
+        }
+        return items;
+      }
+      items.push({
+        id: item.id,
+        language: item.language,
+        version: item.version,
+        renderedFieldIds: [fieldId]
+      });
+      return items;
+    }
+    function closestFieldElement(element) {
+      return element && element.closest ? element.closest("[data-fieldid]") : null;
+    }
+    function closestMediaElement(element) {
+      return element && element.closest ? element.closest("picture,img") : null;
+    }
+    function getCurrentPictureSource(mediaElement) {
+      if (!mediaElement) return null;
+      if (mediaElement.tagName && mediaElement.tagName.toLowerCase() === "img") {
+        return mediaElement;
+      }
+      var sources = Array.prototype.slice.call(
+        mediaElement.querySelectorAll("source")
+      );
+      var currentSource = null;
+      sources.forEach(function(source) {
+        var media = source.getAttribute("media");
+        if (!media) return;
+        try {
+          if (window.matchMedia(media).matches) {
+            currentSource = source;
+          }
+        } catch (error) {
+        }
+      });
+      return currentSource || mediaElement.querySelector("img") || mediaElement;
+    }
+    function closestComponentElement(element) {
+      return element && element.closest ? element.closest(
+        "[data-component-start], [data-component-id], [data-renderingid], [data-rendering-id]"
+      ) : null;
+    }
+    function findEnclosingMarkerElement(startElement, startAttribute, endAttribute) {
+      if (!startElement || !startElement.ownerDocument) return null;
+      var markers = Array.prototype.slice.call(
+        startElement.ownerDocument.querySelectorAll("[" + startAttribute + "]")
+      );
+      var bestMarker = null;
+      markers.forEach(function(marker) {
+        if (!isNodeBeforeOrContains(marker, startElement)) return;
+        var endMarker = findMatchingEndMarker(marker, startAttribute, endAttribute);
+        if (endMarker && !isNodeBeforeOrContains(startElement, endMarker)) {
+          return;
+        }
+        if (!bestMarker || isNodeBefore(bestMarker, marker)) {
+          bestMarker = marker;
+        }
+      });
+      return bestMarker;
+    }
+    function findMatchingEndMarker(marker, startAttribute, endAttribute) {
+      var markerId = marker.getAttribute(startAttribute);
+      if (!markerId) return null;
+      var endMarkers = Array.prototype.slice.call(
+        marker.ownerDocument.querySelectorAll("[" + endAttribute + "]")
+      );
+      return endMarkers.filter(function(endMarker) {
+        return endMarker.getAttribute(endAttribute) === markerId && isNodeBefore(marker, endMarker);
+      })[0] || null;
+    }
+    function isNodeBefore(left, right) {
+      if (!left || !right || left === right) return false;
+      return !!(left.compareDocumentPosition(right) & Node.DOCUMENT_POSITION_FOLLOWING);
+    }
+    function isNodeBeforeOrContains(left, right) {
+      if (!left || !right) return false;
+      return left === right || left.contains && left.contains(right) || isNodeBefore(left, right);
+    }
+    function findNearestComponentElement(startElement) {
+      var current = startElement;
+      while (current) {
+        var directComponentId = current.getAttribute("data-component-id");
+        if (directComponentId && isEditableComponent(current)) return current;
+        current = current.parentElement;
+      }
+      current = closestComponentElement(startElement);
+      if (current && isEditableComponent(current)) return current;
+      current = startElement;
+      while (current) {
+        if (current.hasAttribute("data-component-start") && !current.hasAttribute("data-skip-component") && isEditableComponent(current)) {
+          return current;
+        }
+        current = current.parentElement;
+      }
+      current = findEnclosingMarkerElement(
+        startElement,
+        "data-component-start",
+        "data-component-end"
+      );
+      if (current && !current.hasAttribute("data-skip-component") && isEditableComponent(current)) {
+        return current;
+      }
+      current = startElement;
+      while (current) {
+        var itemId = current.getAttribute("data-itemid");
+        if (itemId && isEditableComponent(current)) return current;
+        current = current.parentElement;
+      }
+      current = startElement;
+      while (current) {
+        if (current.hasAttribute("data-component-start") && !current.hasAttribute("data-skip-component") && isEditableComponent(current)) {
+          return current;
+        }
+        var previous = current.previousElementSibling;
+        current = previous || current.parentElement;
+      }
+      return null;
+    }
+    function closestPlaceholderElement(element) {
+      var current = element && element.closest ? element.closest(
+        "[data-placeholder-start], [data-placeholder-key], [data-placeholderkey]"
+      ) : null;
+      return current || findEnclosingMarkerElement(
+        element,
+        "data-placeholder-start",
+        "data-placeholder-end"
+      );
+    }
+    function isElementHidden(element) {
+      return element.hidden || getComputedStyle(element).display === "none" || getComputedStyle(element).visibility === "hidden";
+    }
+    function isEditableComponent(element) {
+      return element.getAttribute("data-editable") !== "false";
+    }
+    function applySelectionClasses() {
+      Array.prototype.slice.call(document.querySelectorAll("[data-parhelia-selected='true']")).forEach(function(element) {
+        element.removeAttribute("data-parhelia-selected");
+      });
+      knownSelectedComponents.forEach(function(componentId) {
+        var element = findTargetElement({ componentId });
+        if (element) {
+          element.setAttribute("data-parhelia-selected", "true");
+        }
+      });
+    }
+    function setEditingEnabled(enabled) {
+      Array.prototype.slice.call(document.querySelectorAll("[contenteditable]")).forEach(function(element) {
+        if (enabled) {
+          element.setAttribute("contenteditable", "true");
+        } else {
+          element.setAttribute("contenteditable", "false");
+          element.blur();
+        }
+      });
+    }
+    function applyHostZoom(value) {
+      var documentElement = document.documentElement;
+      if (!documentElement) return;
+      var zoom = Number(value);
+      if (!Number.isFinite(zoom) || zoom <= 0) {
+        zoom = 1;
+      }
+      if (zoomAnimationFrame) {
+        cancelAnimationFrame(zoomAnimationFrame);
+        zoomAnimationFrame = 0;
+      }
+      documentElement.style.removeProperty("transition");
+      function getCurrentZoom() {
+        var inlineZoom = Number.parseFloat(documentElement.style.zoom);
+        if (Number.isFinite(inlineZoom) && inlineZoom > 0) return inlineZoom;
+        var computedZoom = Number.parseFloat(
+          getComputedStyle(documentElement).zoom
+        );
+        if (Number.isFinite(computedZoom) && computedZoom > 0) {
+          return computedZoom;
+        }
+        return 1;
+      }
+      function applyFinalZoom() {
+        if (Math.abs(zoom - 1) < 1e-3) {
+          documentElement.style.removeProperty("zoom");
+          documentElement.style.removeProperty("transform");
+          documentElement.style.removeProperty("transform-origin");
+          documentElement.style.removeProperty("overflow");
+          documentElement.style.removeProperty("will-change");
+          return;
+        }
+        documentElement.style.zoom = String(zoom);
+        documentElement.style.removeProperty("transform");
+        documentElement.style.removeProperty("transform-origin");
+        documentElement.style.overflow = "auto";
+        documentElement.style.removeProperty("will-change");
+      }
+      var reduceMotion = false;
+      try {
+        reduceMotion = matchMedia("(prefers-reduced-motion: reduce)").matches;
+      } catch (error) {
+      }
+      if (reduceMotion) {
+        applyFinalZoom();
+        return;
+      }
+      var startZoom = getCurrentZoom();
+      var targetZoom = zoom;
+      if (Math.abs(startZoom - targetZoom) < 1e-3) {
+        applyFinalZoom();
+        return;
+      }
+      documentElement.style.willChange = "zoom";
+      documentElement.style.zoom = String(startZoom);
+      if (Math.abs(targetZoom - 1) >= 1e-3) {
+        documentElement.style.overflow = "auto";
+      }
+      documentElement.style.removeProperty("transform");
+      documentElement.style.removeProperty("transform-origin");
+      var startedAt = performance.now();
+      function easeInOut(value2) {
+        return value2 < 0.5 ? 4 * value2 * value2 * value2 : 1 - Math.pow(-2 * value2 + 2, 3) / 2;
+      }
+      function step(now) {
+        var progress = Math.min(1, (now - startedAt) / ZOOM_TRANSITION_MS);
+        var currentZoom = startZoom + (targetZoom - startZoom) * easeInOut(progress);
+        documentElement.style.zoom = String(currentZoom);
+        documentElement.style.removeProperty("transform");
+        documentElement.style.removeProperty("transform-origin");
+        if (Math.abs(targetZoom - 1) >= 1e-3) {
+          documentElement.style.overflow = "auto";
+        }
+        if (progress < 1) {
+          zoomAnimationFrame = requestAnimationFrame(step);
+          return;
+        }
+        zoomAnimationFrame = 0;
+        applyFinalZoom();
+      }
+      zoomAnimationFrame = requestAnimationFrame(step);
+    }
+    function applyHostZoomInstant(value) {
+      var documentElement = document.documentElement;
+      if (!documentElement) return;
+      var zoom = Number(value);
+      if (!Number.isFinite(zoom) || zoom <= 0) {
+        zoom = 1;
+      }
+      if (Math.abs(zoom - 1) < 1e-3) {
+        documentElement.style.removeProperty("zoom");
+        documentElement.style.removeProperty("transform");
+        documentElement.style.removeProperty("transform-origin");
+        documentElement.style.removeProperty("overflow");
+        documentElement.style.removeProperty("will-change");
+        return;
+      }
+      documentElement.style.zoom = String(zoom);
+      documentElement.style.removeProperty("transform");
+      documentElement.style.removeProperty("transform-origin");
+      documentElement.style.overflow = "auto";
+      documentElement.style.removeProperty("will-change");
+    }
+    function rememberHostZoom(value) {
+      try {
+        sessionStorage.setItem("parhelia:hostZoom", String(Number(value) || 1));
+      } catch (error) {
+      }
+    }
+    function hostScrollPageKey() {
+      return location.pathname + "|" + (getQueryValue("sc_itemid") || "");
+    }
+    function rememberHostScroll() {
+      try {
+        var x = window.scrollX || 0;
+        var y = window.scrollY || 0;
+        if (!x && !y) return;
+        sessionStorage.setItem(
+          "parhelia:hostScroll",
+          JSON.stringify({ x, y, key: hostScrollPageKey(), t: Date.now() })
+        );
+      } catch (error) {
+      }
+    }
+    function applyRememberedHostScroll() {
+      try {
+        var raw = sessionStorage.getItem("parhelia:hostScroll");
+        if (!raw) return;
+        sessionStorage.removeItem("parhelia:hostScroll");
+        var saved = JSON.parse(raw);
+        if (!saved || saved.key !== hostScrollPageKey()) return;
+        if (typeof saved.t === "number" && Date.now() - saved.t > 15e3) return;
+        if (!saved.x && !saved.y) return;
+        restoreRefreshScroll(saved.x, saved.y);
+      } catch (error) {
+      }
+    }
+    function applyRememberedHostZoom() {
+      try {
+        var value = sessionStorage.getItem("parhelia:hostZoom");
+        if (value) applyHostZoomInstant(value);
+      } catch (error) {
+      }
+    }
+    function getTextOffset(root, targetNode, localOffset) {
+      var offset = 0;
+      var walker = document.createTreeWalker(root, NodeFilter.SHOW_TEXT);
+      while (walker.nextNode()) {
+        var current = walker.currentNode;
+        if (current === targetNode) {
+          return offset + localOffset;
+        }
+        offset += current.textContent ? current.textContent.length : 0;
+      }
+      return localOffset;
+    }
+    function measureTextRangeClientRects(root, start, end) {
+      var text = root.textContent || "";
+      var boundedStart = Math.max(0, Math.min(Number(start) || 0, text.length));
+      var boundedEnd = Math.max(
+        boundedStart,
+        Math.min(Number(end) || boundedStart, text.length)
+      );
+      if (boundedStart >= boundedEnd) {
+        return measureCollapsedTextRangeClientRects(root, boundedStart);
+      }
+      var range = createRangeFromTextOffsets(root, boundedStart, boundedEnd);
+      if (!range) return [];
+      return Array.prototype.slice.call(range.getClientRects()).filter(hasVisibleRect);
+    }
+    function measureCollapsedTextRangeClientRects(root, offset) {
+      var range = createRangeFromTextOffsets(root, offset, offset);
+      if (!range) return [];
+      var rect = range.getBoundingClientRect();
+      if (hasVisibleRect(rect)) return [rect];
+      var marker = document.createElement("span");
+      marker.setAttribute("data-parhelia-caret-measure", "true");
+      marker.style.display = "inline-block";
+      marker.style.width = "0";
+      marker.style.height = "1em";
+      marker.style.overflow = "hidden";
+      marker.textContent = "\u200B";
+      try {
+        range.insertNode(marker);
+        rect = marker.getBoundingClientRect();
+        return hasVisibleRect(rect) ? [rect] : [];
+      } catch (error) {
+        return [];
+      } finally {
+        if (marker.parentNode) {
+          marker.parentNode.removeChild(marker);
+        }
+      }
+    }
+    function createRangeFromTextOffsets(root, start, end) {
+      var startData = getTextNodeAtOffset(root, start, "forward");
+      var endData = getTextNodeAtOffset(root, end, "backward");
+      if (!startData || !endData) return null;
+      try {
+        var textRange = document.createRange();
+        textRange.setStart(startData.node, startData.offset);
+        textRange.setEnd(endData.node, endData.offset);
+        return textRange;
+      } catch (error) {
+        return null;
+      }
+    }
+    function getTextNodeAtOffset(root, offset, affinity) {
+      var walker = document.createTreeWalker(root, NodeFilter.SHOW_TEXT);
+      var currentNode;
+      var boundaryNode = null;
+      var remaining = offset;
+      while (currentNode = walker.nextNode()) {
+        var nodeLength = currentNode.textContent ? currentNode.textContent.length : 0;
+        if (remaining < nodeLength) {
+          return { node: currentNode, offset: remaining };
+        }
+        if (remaining === nodeLength) {
+          if (affinity === "backward") {
+            return { node: currentNode, offset: remaining };
+          }
+          boundaryNode = currentNode;
+          remaining = 0;
+          continue;
+        }
+        remaining -= nodeLength;
+      }
+      return boundaryNode ? {
+        node: boundaryNode,
+        offset: boundaryNode.textContent ? boundaryNode.textContent.length : 0
+      } : null;
+    }
+    function getSelectionContext(root, startOffset, endOffset) {
+      var fullText = root.textContent || "";
+      var contextSize = 100;
+      return {
+        contextBefore: sanitizeSelectionText(
+          fullText.slice(Math.max(0, startOffset - contextSize), startOffset)
+        ),
+        contextAfter: sanitizeSelectionText(
+          fullText.slice(endOffset, endOffset + contextSize)
+        )
+      };
+    }
+    function sanitizeSelectionText(text) {
+      return String(text || "").replace(/[\u200B\u200C\u200D\uFEFF\u2060]/g, "");
+    }
+    function getSelectionRect(range) {
+      var rects = Array.prototype.slice.call(range.getClientRects());
+      var visibleRects = rects.filter(hasVisibleRect);
+      if (visibleRects.length > 0) {
+        return visibleRects[visibleRects.length - 1];
+      }
+      var rect = range.getBoundingClientRect();
+      return hasVisibleRect(rect) ? rect : void 0;
+    }
+    function toNumber(value) {
+      if (!value) return void 0;
+      var parsed = parseInt(value, 10);
+      return Number.isFinite(parsed) ? parsed : void 0;
+    }
+    function cssEscape(value) {
+      if (window.CSS && typeof window.CSS.escape === "function") {
+        return window.CSS.escape(value);
+      }
+      return String(value).replace(/["\\]/g, "\\$&");
+    }
+    function isBridgeDebugEnabled() {
+      try {
+        var params = new URLSearchParams(location.search);
+        if (params.get("parhelia_bridge_debug") === "1") return true;
+        var stored = window.localStorage.getItem("parhelia:bridge:debug");
+        return stored === "1" || stored === "true";
+      } catch (error) {
+        return false;
+      }
+    }
+    function logBridgeMessage(direction, message) {
+      if (!shouldLogBridgeMessage(message)) return;
+      var safeMessage = redactSensitiveBridgeFields(message);
+      var name = safeMessage && typeof safeMessage === "object" && typeof safeMessage.name === "string" ? ": " + safeMessage.name : "";
+      console.log("[Parhelia bridge message] " + direction + name, safeMessage);
+      console.groupCollapsed("[Parhelia bridge] " + direction + name);
+      console.log(safeMessage);
+      console.groupEnd();
+    }
+    function shouldLogBridgeMessage(message) {
+      if (!isBridgeDebugEnabled()) return false;
+      if (!isHighFrequencyBridgeMessage(message)) return true;
+      return isVerboseBridgeDebugEnabled();
+    }
+    function isHighFrequencyBridgeMessage(message) {
+      return message && typeof message === "object" && (message.name === "scrollChanged" || message.name === "geometryUpdated" || message.name === "domUpdated" || message.name === "selectionChanged");
+    }
+    function isVerboseBridgeDebugEnabled() {
+      try {
+        var params = new URLSearchParams(location.search);
+        if (params.get("parhelia_bridge_debug") === "verbose") return true;
+        if (params.get("parhelia_bridge_verbose") === "1") return true;
+        var stored = window.localStorage.getItem("parhelia:bridge:debug:verbose");
+        return stored === "1" || stored === "true";
+      } catch (error) {
+        return false;
+      }
+    }
+    function redactSensitiveBridgeFields(value) {
+      if (Array.isArray(value)) {
+        return value.map(redactSensitiveBridgeFields);
+      }
+      if (!value || typeof value !== "object") {
+        return value;
+      }
+      var result = {};
+      Object.keys(value).forEach(function(key) {
+        if (/token|secret|signedContext|sessionId/i.test(key)) {
+          result[key] = "[redacted]";
+        } else {
+          result[key] = redactSensitiveBridgeFields(value[key]);
+        }
+      });
+      return result;
+    }
+  })();
+})();