@diplodoc/transform 4.70.4 → 4.71.0

package/dist/js/yfm.js

@@ -493,26 +493,365 @@
     });
   }
 
-  // src/js/anchor.ts
-  var ANCHOR_BUTTON_SELECTOR = ".yfm-clipboard-anchor";
-  if (typeof document !== "undefined") {
-    document.addEventListener("click", (event) => {
-      const target = getEventTarget(event);
-      if (isCustom(event) || !target.matches(ANCHOR_BUTTON_SELECTOR)) {
-        return;
+  // src/js/tooltip/constant.ts
+  var PAGE_CONTAINER_SELECTOR = ".dc-doc-page__content";
+  var TOOLTIP_BASE_CLASS = "yfm yfm-tooltip";
+  var TOOLTIP_OPEN_CLASS = "open";
+  var TOOLTIP_DATA_ATTR = "data-tooltip-id";
+  var DEFAULT_OFFSET_VALUES = { mainAxis: 5 };
+  var OPPOSITE_SIDES = {
+    top: "bottom",
+    bottom: "top",
+    left: "right",
+    right: "left"
+  };
+  var DEFAULT_SIDE_OBJECT = {
+    top: 0,
+    bottom: 0,
+    left: 0,
+    right: 0
+  };
+
+  // src/js/tooltip/utils.ts
+  function isVerticalSide(side) {
+    return side === "top" || side === "bottom";
+  }
+  function createSideObject(value = 0) {
+    if (typeof value === "number") {
+      return { top: value, bottom: value, left: value, right: value };
+    }
+    return { ...DEFAULT_SIDE_OBJECT, ...value };
+  }
+  function parsePlacement(placement) {
+    const [side, alignment] = placement.split("-");
+    return { side, alignment };
+  }
+  function getOppositeSide(side) {
+    return OPPOSITE_SIDES[side];
+  }
+  function flipPlacement(placement) {
+    const { side, alignment } = parsePlacement(placement);
+    const opposite = getOppositeSide(side);
+    return alignment ? `${opposite}-${alignment}` : opposite;
+  }
+  function getOverflow(tooltip3, coords, viewport) {
+    const rect = updateRect(tooltip3, { top: coords.y, left: coords.x });
+    return detectOverflow(viewport, rect, 5);
+  }
+  function shouldFlip(overflow, flippedOverflow, side) {
+    const opposite = getOppositeSide(side);
+    return overflow[side] > 0 && flippedOverflow[opposite] < overflow[side];
+  }
+  function computePosition(reference, tooltip3, viewport, placement, offset, isRtl, flip = true) {
+    const coords = computeCoordsFromPlacement(reference, tooltip3, offset, placement, isRtl);
+    if (!flip) {
+      return { coords, placement };
+    }
+    const overflow = getOverflow(tooltip3, coords, viewport);
+    const { side } = parsePlacement(placement);
+    if (overflow[side] <= 0) {
+      return { coords, placement };
+    }
+    const flipped = flipPlacement(placement);
+    const flippedCoords = computeCoordsFromPlacement(reference, tooltip3, offset, flipped, isRtl);
+    const flippedOverflow = getOverflow(tooltip3, flippedCoords, viewport);
+    if (shouldFlip(overflow, flippedOverflow, side)) {
+      return { coords: flippedCoords, placement: flipped };
+    }
+    return { coords, placement };
+  }
+  function generateId() {
+    const random = Math.random().toString(36).substring(2, 6);
+    const now = Date.now().toString(36);
+    return `${random}${now}`;
+  }
+  function createRect(params) {
+    return {
+      ...params,
+      right: params.left + params.width,
+      bottom: params.top + params.height
+    };
+  }
+  function updateRect(rect, params) {
+    var _a, _b, _c, _d;
+    return createRect({
+      top: (_a = params.top) != null ? _a : rect.top,
+      left: (_b = params.left) != null ? _b : rect.left,
+      width: (_c = params.width) != null ? _c : rect.width,
+      height: (_d = params.height) != null ? _d : rect.height
+    });
+  }
+  function getViewportRect() {
+    const { documentElement, body } = document;
+    const scrollTop = window.scrollY || documentElement.scrollTop || body.scrollTop;
+    const scrollLeft = window.scrollX || documentElement.scrollLeft || body.scrollLeft;
+    const clientTop = documentElement.clientTop || body.clientTop || 0;
+    const clientLeft = documentElement.clientLeft || body.clientLeft || 0;
+    return createRect({
+      top: Math.round(scrollTop - clientTop),
+      left: Math.round(scrollLeft - clientLeft),
+      width: document.body.clientWidth,
+      height: document.body.clientHeight
+    });
+  }
+  function getElementRect(element) {
+    const viewport = getViewportRect();
+    const box = element.getBoundingClientRect();
+    return createRect({
+      top: Math.round(box.top + viewport.top),
+      left: Math.round(box.left + viewport.left),
+      width: box.width,
+      height: box.height
+    });
+  }
+  function computeAxisOffset(offset, side, isRtl) {
+    const { mainAxis = 0, crossAxis = 0 } = offset;
+    const isVertical = isVerticalSide(side);
+    const mainDirection = side === "top" || side === "left" ? -1 : 1;
+    const crossDirection = isRtl && isVertical ? -1 : 1;
+    const mainOffset = mainAxis * mainDirection;
+    const crossOffset = crossAxis * crossDirection;
+    if (isVertical) {
+      return { x: crossOffset, y: mainOffset };
+    }
+    return { x: mainOffset, y: crossOffset };
+  }
+  function computeCoordsFromPlacement(reference, tooltip3, offset, placement, isRtl) {
+    const { side, alignment } = parsePlacement(placement);
+    const isVertical = isVerticalSide(side);
+    const alignmentAxis = isVertical ? "x" : "y";
+    const alignLength = alignmentAxis === "y" ? "height" : "width";
+    const centerX = reference.left + reference.width / 2 - tooltip3.width / 2;
+    const centerY = reference.top + reference.height / 2 - tooltip3.height / 2;
+    const alignmentOffset = reference[alignLength] / 2 - tooltip3[alignLength] / 2;
+    const coords = { x: reference.left, y: reference.top };
+    switch (side) {
+      case "top": {
+        coords.x = centerX;
+        coords.y = reference.top - tooltip3.height;
+        break;
+      }
+      case "bottom": {
+        coords.x = centerX;
+        coords.y = reference.top + reference.height;
+        break;
+      }
+      case "right": {
+        coords.x = reference.left + reference.width;
+        coords.y = centerY;
+        break;
+      }
+      case "left": {
+        coords.x = reference.left - tooltip3.width;
+        coords.y = centerY;
+        break;
       }
-      const href = target.getAttribute("data-href") || "";
-      const link = new URL(href, window.location.href).toString();
-      copyToClipboard(link);
+    }
+    switch (alignment) {
+      case "start": {
+        coords[alignmentAxis] -= alignmentOffset * (isRtl && isVertical ? -1 : 1);
+        break;
+      }
+      case "end": {
+        coords[alignmentAxis] += alignmentOffset * (isRtl && isVertical ? -1 : 1);
+        break;
+      }
+    }
+    const axisOffset = computeAxisOffset(offset, side, isRtl);
+    coords.x += axisOffset.x;
+    coords.y += axisOffset.y;
+    return coords;
+  }
+  function convertToRelativeToOffsetParentRect(rect, offsetParent) {
+    const offsetRect = getElementRect(offsetParent);
+    return createRect({
+      top: rect.top - offsetRect.top + offsetParent.offsetTop,
+      left: rect.left - offsetRect.left + offsetParent.offsetLeft,
+      width: rect.width,
+      height: rect.height
     });
   }
+  function detectOverflow(boundary, element, padding = 0) {
+    const { top, bottom, left, right } = createSideObject(padding);
+    return {
+      top: boundary.top - element.top + top,
+      bottom: element.bottom - boundary.bottom + bottom,
+      left: boundary.left - element.left + left,
+      right: element.right - boundary.right + right
+    };
+  }
 
-  // src/js/inline-code/constant.ts
-  var INLINE_CODE = ".yfm-clipboard-inline-code";
-  var INLINE_CODE_ID = "tooltip_inline_clipboard_dialog";
-  var INLINE_CODE_CLASS = "yfm inline_code_tooltip";
-  var OPEN_CLASS = "open";
-  var LANG_TOKEN = {
+  // src/js/tooltip/tooltip.ts
+  function createTooltipFactory(options = {}) {
+    const { closeDelay = 1e3, additionalClassName } = options;
+    let initialized = false;
+    const state = {
+      currentId: null,
+      timer: null,
+      unsubscribe: null
+    };
+    const getActiveTooltip = () => {
+      if (!state.currentId) {
+        return null;
+      }
+      return document.getElementById(state.currentId);
+    };
+    const getActiveReference = () => {
+      if (!state.currentId) {
+        return null;
+      }
+      return getReferenceByTooltipId(state.currentId);
+    };
+    const hide = () => {
+      const tooltip3 = getActiveTooltip();
+      if (state.timer) {
+        clearTimeout(state.timer);
+        state.timer = null;
+      }
+      if (state.unsubscribe) {
+        state.unsubscribe();
+        state.unsubscribe = null;
+      }
+      if (tooltip3) {
+        tooltip3.classList.remove(TOOLTIP_OPEN_CLASS);
+        detachTooltip(tooltip3);
+        state.currentId = null;
+      }
+    };
+    const show = (reference, text) => {
+      hide();
+      const tooltip3 = createTooltipElement({ text, className: additionalClassName });
+      const update = updateTooltipPosition.bind(null, options, reference, tooltip3);
+      state.currentId = tooltip3.id;
+      attachTooltip(tooltip3, reference);
+      state.unsubscribe = subscribeToScroll(reference, update);
+      tooltip3.classList.add(TOOLTIP_OPEN_CLASS);
+      update();
+      if (closeDelay > 0) {
+        state.timer = setTimeout(hide, closeDelay);
+      }
+    };
+    const handleUpdate = () => {
+      const activeTooltip = getActiveTooltip();
+      const activeReference = getActiveReference();
+      if (activeTooltip && !activeReference) {
+        hide();
+        return;
+      }
+      if (activeTooltip && activeReference) {
+        updateTooltipPosition(options, activeReference, activeTooltip);
+      }
+    };
+    const init = () => {
+      if (!initialized) {
+        initialized = true;
+        window.addEventListener("scroll", handleUpdate);
+        window.addEventListener("resize", handleUpdate);
+      }
+    };
+    const cleanup = () => {
+      if (initialized) {
+        initialized = false;
+        window.removeEventListener("scroll", handleUpdate);
+        window.removeEventListener("resize", handleUpdate);
+      }
+    };
+    return {
+      get visible() {
+        return Boolean(state.currentId);
+      },
+      getActiveReference,
+      show,
+      hide,
+      init,
+      cleanup
+    };
+  }
+  function createTooltipElement(options) {
+    const { text, className } = options;
+    const id = generateId();
+    const tooltip3 = document.createElement("div");
+    tooltip3.id = id;
+    tooltip3.className = className ? `${TOOLTIP_BASE_CLASS} ${className}` : TOOLTIP_BASE_CLASS;
+    tooltip3.setAttribute("role", "tooltip");
+    tooltip3.setAttribute("aria-live", "polite");
+    tooltip3.textContent = text;
+    return tooltip3;
+  }
+  function attachTooltip(tooltip3, reference) {
+    const container2 = document.querySelector(PAGE_CONTAINER_SELECTOR) || document.body;
+    const ariaLive = reference.getAttribute("aria-live");
+    reference.setAttribute(TOOLTIP_DATA_ATTR, tooltip3.id);
+    if (ariaLive) {
+      tooltip3.setAttribute("aria-live", ariaLive);
+    }
+    container2.appendChild(tooltip3);
+  }
+  function detachTooltip(tooltip3) {
+    if (tooltip3.id) {
+      const reference = getReferenceByTooltipId(tooltip3.id);
+      reference == null ? void 0 : reference.removeAttribute(TOOLTIP_DATA_ATTR);
+    }
+    tooltip3.remove();
+  }
+  function getReferenceByTooltipId(id) {
+    return document.querySelector(`[${TOOLTIP_DATA_ATTR}="${id}"]`);
+  }
+  function subscribeToScroll(reference, update) {
+    const scrollableElement = getParentScrollableElement(reference);
+    scrollableElement.addEventListener("scroll", update);
+    return () => {
+      scrollableElement.removeEventListener("scroll", update);
+    };
+  }
+  function getParentScrollableElement(target) {
+    const closestScrollableParent = target.closest("table") || target.closest("code");
+    return closestScrollableParent || target.parentElement || document.body;
+  }
+  function createTooltipContext(referenceElement, tooltipElement) {
+    const tooltipParent = tooltipElement.parentElement;
+    if (!tooltipParent) {
+      return null;
+    }
+    const elements = {
+      reference: referenceElement,
+      tooltip: tooltipElement,
+      offsetParent: tooltipParent
+    };
+    const viewport = getViewportRect();
+    const reference = getElementRect(referenceElement);
+    const { width, height } = tooltipElement.getBoundingClientRect();
+    return {
+      isRtl: document.dir === "rtl",
+      viewport,
+      reference,
+      tooltip: createRect({ top: 0, left: 0, width, height }),
+      elements
+    };
+  }
+  function updateTooltipPosition(options, referenceElement, tooltipElement) {
+    const context = createTooltipContext(referenceElement, tooltipElement);
+    if (!context) {
+      return;
+    }
+    const coords = getTooltipCoords(context, options);
+    tooltipElement.style.top = `${coords.y}px`;
+    tooltipElement.style.left = `${coords.x}px`;
+  }
+  function getTooltipCoords(context, options) {
+    const { placement = "bottom-start", offset = DEFAULT_OFFSET_VALUES, flip = true } = options;
+    const { reference, tooltip: tooltip3, viewport, isRtl } = context;
+    const { coords } = computePosition(reference, tooltip3, viewport, placement, offset, isRtl, flip);
+    const rect = updateRect(tooltip3, { top: coords.y, left: coords.x });
+    const relativeRect = convertToRelativeToOffsetParentRect(rect, context.elements.offsetParent);
+    return {
+      x: relativeRect.left,
+      y: relativeRect.top
+    };
+  }
+
+  // src/js/constant.ts
+  var COPIED_LANG_TOKEN = {
     ru: "\u0421\u043A\u043E\u043F\u0438\u0440\u043E\u0432\u0430\u043D\u043E",
     en: "Copied",
     ar: "\u062A\u0645 \u0627\u0644\u0646\u0633\u062E",
@@ -531,6 +870,80 @@
     uz: "Nusxalandi"
   };
 
+  // src/js/anchor.ts
+  var ALLOWED_PROTOCOL_RE = /^(?:https?|file):$/;
+  var ANCHOR_BUTTON_SELECTOR = ".yfm-clipboard-anchor";
+  var tooltip = createTooltipFactory();
+  function getLink(target) {
+    const href = target.nodeName === "A" ? target.href : target.dataset.href;
+    const link = new URL(href || "", window.location.href);
+    if (ALLOWED_PROTOCOL_RE.test(link.protocol)) {
+      return link.href;
+    }
+    return window.location.href;
+  }
+  if (typeof document !== "undefined") {
+    tooltip.init();
+    document.addEventListener("click", (event) => {
+      const target = getEventTarget(event);
+      if (isCustom(event) || !target.matches(ANCHOR_BUTTON_SELECTOR)) {
+        return;
+      }
+      const link = getLink(target);
+      copyToClipboard(link).then(() => {
+        var _a;
+        const lang = document.documentElement.lang || "en";
+        const tooltipText = (_a = COPIED_LANG_TOKEN[lang]) != null ? _a : COPIED_LANG_TOKEN.en;
+        tooltip.show(target, tooltipText);
+      });
+    });
+  }
+
+  // src/js/inline-code/index.ts
+  var CLASS_INLINE_CODE = "yfm-clipboard-inline-code";
+  var INLINE_CODE = `.${CLASS_INLINE_CODE}`;
+  var tooltip2 = createTooltipFactory({
+    // NOTE: Add additional className for backward capability
+    additionalClassName: "inline_code_tooltip"
+  });
+  function inlineCopyFn(target) {
+    const innerText = target.innerText;
+    if (!innerText) {
+      return;
+    }
+    copyToClipboard(innerText).then(() => {
+      var _a;
+      const lang = document.documentElement.lang || "en";
+      const tooltipText = (_a = COPIED_LANG_TOKEN[lang]) != null ? _a : COPIED_LANG_TOKEN.en;
+      tooltip2.show(target, tooltipText);
+    });
+  }
+  if (typeof document !== "undefined") {
+    tooltip2.init();
+    document.addEventListener("click", (event) => {
+      const target = getEventTarget(event);
+      const inline = target.matches(INLINE_CODE);
+      if (isCustom(event) || !inline) {
+        return;
+      }
+      inlineCopyFn(target);
+    });
+    document.addEventListener("keydown", (event) => {
+      if (event.key === "Enter" && document.activeElement) {
+        const activeElement = document.activeElement;
+        if (!activeElement.classList.contains(CLASS_INLINE_CODE)) {
+          return;
+        }
+        inlineCopyFn(activeElement);
+      }
+      if (event.key === "Escape" && tooltip2.visible) {
+        const reference = tooltip2.getActiveReference();
+        tooltip2.hide();
+        reference == null ? void 0 : reference.focus();
+      }
+    });
+  }
+
   // src/js/term/utils.ts
   var Selector = {
     TITLE: ".yfm .yfm-term_title",
@@ -716,218 +1129,6 @@
     return document.getElementById(termId);
   }
 
-  // src/js/inline-code/utils.ts
-  var timer = null;
-  var isListenerNeeded2 = true;
-  function getTooltipElement() {
-    return document.getElementById(INLINE_CODE_ID);
-  }
-  function setTooltipAriaAttributes(tooltipElement, targetElement) {
-    const ariaLive = targetElement.getAttribute("aria-live") || "polite";
-    tooltipElement == null ? void 0 : tooltipElement.setAttribute("aria-live", ariaLive);
-    tooltipElement == null ? void 0 : tooltipElement.setAttribute("aria-modal", "true");
-  }
-  function checkTimerAndClear() {
-    if (timer) {
-      clearTimeout(timer);
-      timer = null;
-    }
-  }
-  function tooltipParentElement(target) {
-    if (!target) {
-      return null;
-    }
-    const closestScrollableParent = target.closest("table") || target.closest("code");
-    return closestScrollableParent || target.parentElement;
-  }
-  function tooltipOnResize() {
-    const openedDefinition = getTooltipElement();
-    if (!openedDefinition) {
-      return;
-    }
-    const inlineId = openedDefinition.getAttribute("inline-id") || "";
-    const targetElement = document.getElementById(inlineId);
-    if (!targetElement) {
-      return;
-    }
-    setTooltipPosition(openedDefinition, targetElement);
-  }
-  function setTooltipPosition(tooltipElement, targetElement) {
-    const {
-      x: inlineX,
-      y: inlineY,
-      right: inlineRight,
-      left: inlineLeft,
-      width: inlineWidth,
-      height: inlineHeight
-    } = targetElement.getBoundingClientRect();
-    const tooltipParent = tooltipParentElement(targetElement);
-    if (!tooltipParent) {
-      return;
-    }
-    const { right: tooltipParentRight, left: tooltipParentLeft } = tooltipParent.getBoundingClientRect();
-    if ((tooltipParentRight < inlineLeft || tooltipParentLeft > inlineRight) && !isListenerNeeded2) {
-      closeTooltip(tooltipElement);
-      return;
-    }
-    if (isListenerNeeded2 && tooltipParent) {
-      tooltipParent.addEventListener("scroll", tooltipOnResize);
-      isListenerNeeded2 = false;
-    }
-    const relativeX = Number(tooltipElement.getAttribute("relativeX"));
-    const relativeY = Number(tooltipElement.getAttribute("relativeY"));
-    if (relativeX === inlineX && relativeY === inlineY) {
-      return;
-    }
-    tooltipElement.setAttribute("relativeX", String(inlineX));
-    tooltipElement.setAttribute("relativeY", String(inlineY));
-    const offsetTop = inlineHeight + 5;
-    const definitionParent = tooltipElement.parentElement;
-    if (!definitionParent) {
-      return;
-    }
-    const { width: definitionWidth } = tooltipElement.getBoundingClientRect();
-    const { left: definitionParentLeft } = definitionParent.getBoundingClientRect();
-    const definitionLeftCoordinate = Number(getCoords(targetElement).left);
-    const definitionRightCoordinate = definitionWidth + definitionLeftCoordinate;
-    const definitionOutOfScreenOnLeft = definitionLeftCoordinate - definitionWidth < 0;
-    const definitionOutOfScreenOnRight = definitionRightCoordinate > document.body.clientWidth;
-    const isAlignSwapped = definitionOutOfScreenOnRight || document.dir === "rtl";
-    const fitDefinitionDocument = isAlignSwapped && !definitionOutOfScreenOnLeft ? definitionWidth - inlineWidth : 0;
-    const customHeaderTop = getCoords(definitionParent).top - definitionParent.offsetTop;
-    const offsetRight = 5;
-    const shiftLeft = definitionOutOfScreenOnRight ? definitionRightCoordinate - document.body.clientWidth + offsetRight : 0;
-    const offsetLeft = getCoords(targetElement).left - definitionParentLeft + definitionParent.offsetLeft - fitDefinitionDocument;
-    const isShiftLeftNeeded = offsetLeft + definitionWidth >= document.body.clientWidth;
-    tooltipElement.style.top = Number(getCoords(targetElement).top + offsetTop - customHeaderTop) + "px";
-    tooltipElement.style.left = Number(offsetLeft - (isShiftLeftNeeded ? shiftLeft : 0)) + "px";
-  }
-  function getInlineCodeByTooltip(definition) {
-    const inlineId = definition.getAttribute("inline-id");
-    return inlineId ? document.getElementById(inlineId) : null;
-  }
-  function closeTooltipFn(definition) {
-    definition.classList.remove(OPEN_CLASS);
-    const inline = getInlineCodeByTooltip(definition);
-    const inlineCodepParent = tooltipParentElement(inline);
-    const tooltipParent = tooltipParentElement(definition);
-    definition.removeAttribute("inline-id");
-    if (!inlineCodepParent || !tooltipParent) {
-      return;
-    }
-    tooltipParent.removeChild(definition);
-    inlineCodepParent.removeEventListener("scroll", tooltipOnResize);
-    isListenerNeeded2 = true;
-  }
-  function createTooltip() {
-    var _a;
-    let tooltip = getTooltipElement();
-    if (!tooltip) {
-      const pageContent = document.querySelector(".dc-doc-page__content") || document.body;
-      const lang = document.documentElement.lang || "en";
-      const tooltipText = (_a = LANG_TOKEN[lang]) != null ? _a : LANG_TOKEN.en;
-      const host = document.createElement("div");
-      host.innerHTML = `
-            <div id="${INLINE_CODE_ID}" class="${INLINE_CODE_CLASS}"
-                role="dialog" aria-live="polite" aria-modal="true">
-                ${tooltipText}
-            </div>
-        `;
-      tooltip = host.firstElementChild;
-      pageContent.appendChild(tooltip);
-    }
-    return tooltip;
-  }
-  function openTooltip(target) {
-    const tooltip = createTooltip();
-    if (!target.matches(INLINE_CODE) || !tooltip) {
-      return;
-    }
-    tooltip.setAttribute("inline-id", target.getAttribute("id") || "");
-    setTooltipAriaAttributes(tooltip, target);
-    setTooltipPosition(tooltip, target);
-    if (tooltip.classList.contains(OPEN_CLASS)) {
-      tooltip.classList.remove(OPEN_CLASS);
-      requestAnimationFrame(() => {
-        tooltip.classList.add(OPEN_CLASS);
-      });
-    } else {
-      tooltip.classList.add(OPEN_CLASS);
-    }
-    return tooltip;
-  }
-  function closeTooltip(target) {
-    checkTimerAndClear();
-    closeTooltipFn(target);
-  }
-  function tooltipWorker(target) {
-    const definition = openTooltip(target);
-    if (!definition) {
-      return;
-    }
-    checkTimerAndClear();
-    timer = setTimeout(() => {
-      closeTooltip(definition);
-      timer = null;
-    }, 1e3);
-  }
-
-  // src/js/inline-code/index.ts
-  function inlineCopyFn(target) {
-    const innerText = target.innerText;
-    if (!innerText) {
-      return;
-    }
-    copyToClipboard(innerText).then(() => {
-      tooltipWorker(target);
-    });
-  }
-  if (typeof document !== "undefined") {
-    document.addEventListener("click", (event) => {
-      const target = getEventTarget(event);
-      const inline = target.matches(INLINE_CODE);
-      if (isCustom(event) || !inline) {
-        return;
-      }
-      inlineCopyFn(target);
-    });
-    document.addEventListener("keydown", (event) => {
-      var _a;
-      if (event.key === "Enter" && document.activeElement) {
-        const activeElement = document.activeElement;
-        const classInlineCode = INLINE_CODE.replace(".", "");
-        if (!activeElement.classList.contains(classInlineCode)) {
-          return;
-        }
-        const innerText = activeElement.innerText;
-        if (!innerText) {
-          return;
-        }
-        copyToClipboard(innerText).then(() => {
-          tooltipWorker(activeElement);
-        });
-      }
-      const inlineTooltip = getTooltipElement();
-      if (event.key === "Escape" && inlineTooltip) {
-        closeTooltip(inlineTooltip);
-        (_a = getInlineCodeByTooltip(inlineTooltip)) == null ? void 0 : _a.focus();
-      }
-    });
-    window.addEventListener("resize", () => {
-      const inlineTooltip = getTooltipElement();
-      if (!inlineTooltip) {
-        return;
-      }
-      const inlineId = inlineTooltip.getAttribute("inline-id") || "";
-      const inlineCodeElement = document.getElementById(inlineId);
-      if (!inlineCodeElement) {
-        inlineTooltip.classList.toggle(OPEN_CLASS);
-        return;
-      }
-      setTooltipPosition(inlineTooltip, inlineCodeElement);
-    });
-  }
-
   // src/js/term/index.ts
   if (typeof document !== "undefined") {
     document.addEventListener("click", (event) => {