testplane 9.0.0-rc.3 → 9.0.0

package/build/src/browser/client-scripts/screen-shooter/tsc-out/client-scripts/screen-shooter/utils/clip-rect.js

@@ -0,0 +1,103 @@
+"use strict";
+exports.__esModule = true;
+exports.getClipRect = void 0;
+var _isomorphic_1 = require("@isomorphic");
+var element_rect_1 = require("./element-rect");
+var scroll_1 = require("./scroll");
+var dom_1 = require("./dom");
+var descriptions_1 = require("./descriptions");
+function getViewportRect() {
+    return {
+        top: 0,
+        left: 0,
+        width: window.innerWidth,
+        height: window.innerHeight
+    };
+}
+function hasOverflowClipping(style) {
+    return style.overflow !== "visible" || style.overflowX !== "visible" || style.overflowY !== "visible";
+}
+function getAbsoluteContainingBlocks(element) {
+    var absoluteContainingBlocks = [];
+    var current = element;
+    while (current && !(0, scroll_1.isRootLikeElement)(current)) {
+        var style = getComputedStyle(current);
+        if (style.position === "absolute") {
+            var containingBlock = (0, dom_1.findContainingBlock)(current);
+            absoluteContainingBlocks.push({ absoluteAncestor: current, containingBlock: containingBlock });
+        }
+        current = current.parentElement;
+    }
+    return absoluteContainingBlocks;
+}
+function getFixedAncestors(element) {
+    var fixedAncestors = [];
+    var current = element;
+    while (current && !(0, scroll_1.isRootLikeElement)(current)) {
+        if (getComputedStyle(current).position === "fixed") {
+            fixedAncestors.push(current);
+        }
+        current = current.parentElement;
+    }
+    return fixedAncestors;
+}
+/** Absolute-positioned descendants may escape clipping when their containing block is outside clippingElement */
+function escapesOverflowClippingViaAbsoluteContainingBlocks(clippingElement, absoluteContainingBlocks) {
+    return absoluteContainingBlocks.some(function (_a) {
+        var absoluteAncestor = _a.absoluteAncestor, containingBlock = _a.containingBlock;
+        if (absoluteAncestor === clippingElement || !clippingElement.contains(absoluteAncestor)) {
+            return false;
+        }
+        return containingBlock !== clippingElement && containingBlock.contains(clippingElement);
+    });
+}
+/** Fixed-position descendants escape clipping of ancestors above the fixed ancestor */
+function escapesOverflowClippingViaFixedAncestors(clippingElement, fixedAncestors) {
+    return fixedAncestors.some(function (fixedAncestor) { return fixedAncestor !== clippingElement && clippingElement.contains(fixedAncestor); });
+}
+/**
+ * Computes the clip rect for an element by intersecting the content boxes
+ * of all ancestor elements with overflow clipping, starting from the viewport.
+ *
+ * Elements with `position: fixed` are only clipped by the viewport,
+ * since they are positioned relative to the viewport and escape all
+ * ancestor overflow clipping.
+ */
+function getClipRect(element, logger) {
+    var viewportRect = getViewportRect();
+    var absoluteContainingBlocks = getAbsoluteContainingBlocks(element);
+    var fixedAncestors = getFixedAncestors(element);
+    var clipRect = viewportRect;
+    var current = element.parentElement;
+    while (current) {
+        if ((0, scroll_1.isRootLikeElement)(current)) {
+            break;
+        }
+        var style = getComputedStyle(current);
+        if (hasOverflowClipping(style)) {
+            var isEscapingCurrentOverflowClipping = escapesOverflowClippingViaAbsoluteContainingBlocks(current, absoluteContainingBlocks) ||
+                escapesOverflowClippingViaFixedAncestors(current, fixedAncestors);
+            if (isEscapingCurrentOverflowClipping) {
+                current = current.parentElement;
+                continue;
+            }
+            var contentBox = (0, element_rect_1.getBoundingClientContentRect)(current);
+            logger === null || logger === void 0 ? void 0 : logger("intersecting with:", (0, descriptions_1.getReadableElementDescriptor)(current), "contentBox:", contentBox);
+            var intersection = (0, _isomorphic_1.getIntersection)(clipRect, contentBox);
+            if (!intersection) {
+                logger === null || logger === void 0 ? void 0 : logger("no intersection found for:", (0, descriptions_1.getReadableElementDescriptor)(current));
+                // Element is fully clipped — return zero-sized rect at clip origin
+                return {
+                    top: clipRect.top,
+                    left: clipRect.left,
+                    width: 0,
+                    height: 0
+                };
+            }
+            clipRect = intersection;
+        }
+        current = current.parentElement;
+    }
+    return clipRect;
+}
+exports.getClipRect = getClipRect;

package/build/src/browser/client-scripts/screen-shooter/tsc-out/client-scripts/screen-shooter/utils/descriptions.js

@@ -0,0 +1,19 @@
+"use strict";
+exports.__esModule = true;
+exports.getReadableElementDescriptor = void 0;
+function getReadableElementDescriptor(element) {
+    if (element === document.documentElement)
+        return "html";
+    var tag = element.tagName.toLowerCase();
+    if (element.id)
+        return "".concat(tag, "#").concat(element.id);
+    if (element.classList.length) {
+        var classes = [];
+        for (var i = 0; i < element.classList.length; i++) {
+            classes.push(element.classList[i]);
+        }
+        return tag + "." + classes.join(".");
+    }
+    return tag;
+}
+exports.getReadableElementDescriptor = getReadableElementDescriptor;

package/build/src/browser/client-scripts/screen-shooter/tsc-out/client-scripts/screen-shooter/utils/dom.js

@@ -0,0 +1,99 @@
+"use strict";
+exports.__esModule = true;
+exports.getScreenshooterNamespaceData = exports.findContainingBlock = exports.findFixedPositionedParent = exports.getParentElement = exports.forEachRoot = exports.getMainDocumentElem = exports.getOwnerIframe = exports.getOwnerWindow = void 0;
+var FALLBACK_SCREENSHOOTER_NAMESPACE = "__testplane_screenshooter__";
+function getOwnerWindow(node) {
+    if (!node.ownerDocument) {
+        return null;
+    }
+    return node.ownerDocument.defaultView;
+}
+exports.getOwnerWindow = getOwnerWindow;
+function getOwnerIframe(node) {
+    var nodeWindow = getOwnerWindow(node);
+    if (nodeWindow) {
+        return nodeWindow.frameElement;
+    }
+    return null;
+}
+exports.getOwnerIframe = getOwnerIframe;
+function getMainDocumentElem(currDocumentElem) {
+    if (!currDocumentElem) {
+        currDocumentElem = document.documentElement;
+    }
+    var currIframe = getOwnerIframe(currDocumentElem);
+    if (!currIframe) {
+        return currDocumentElem;
+    }
+    var currWindow = getOwnerWindow(currIframe);
+    if (!currWindow) {
+        return currDocumentElem;
+    }
+    return getMainDocumentElem(currWindow.document.documentElement);
+}
+exports.getMainDocumentElem = getMainDocumentElem;
+function forEachRoot(cb) {
+    function traverseRoots(root) {
+        cb(root);
+        // @ts-expect-error - IE11 requires the third and fourth arguments
+        var treeWalker = document.createTreeWalker(root, NodeFilter.SHOW_ELEMENT, null, false);
+        for (var node = treeWalker.currentNode; node !== null; node = treeWalker.nextNode()) {
+            if (node instanceof Element && node.shadowRoot) {
+                traverseRoots(node.shadowRoot);
+            }
+        }
+    }
+    traverseRoots(document.documentElement);
+}
+exports.forEachRoot = forEachRoot;
+function getParentElement(node) {
+    if (node instanceof ShadowRoot)
+        return node.host;
+    if (node instanceof Element) {
+        var root = node.getRootNode();
+        return node.parentElement || (root instanceof ShadowRoot ? root.host : null);
+    }
+    return node.parentNode instanceof Element ? node.parentNode : null;
+}
+exports.getParentElement = getParentElement;
+function findFixedPositionedParent(element) {
+    var parent = element.parentElement;
+    while (parent) {
+        if (getComputedStyle(parent).position === "fixed") {
+            return parent;
+        }
+        parent = parent.parentElement;
+    }
+    return null;
+}
+exports.findFixedPositionedParent = findFixedPositionedParent;
+function findContainingBlock(element) {
+    var parent = element.parentElement;
+    while (parent) {
+        var style = getComputedStyle(parent);
+        if (style.position === "relative" ||
+            style.position === "absolute" ||
+            style.position === "fixed" ||
+            style.position === "sticky" ||
+            style.transform !== "none" ||
+            style.perspective !== "none") {
+            return parent;
+        }
+        parent = parent.parentElement;
+    }
+    return document.documentElement;
+}
+exports.findContainingBlock = findContainingBlock;
+function getScreenshooterNamespaceData() {
+    if (!window.__geminiCore) {
+        window.__geminiCore = {};
+    }
+    var namespace = typeof __geminiNamespace === "string" && __geminiNamespace
+        ? __geminiNamespace
+        : FALLBACK_SCREENSHOOTER_NAMESPACE;
+    if (!window.__geminiCore[namespace]) {
+        window.__geminiCore[namespace] = {};
+    }
+    return window.__geminiCore[namespace];
+}
+exports.getScreenshooterNamespaceData = getScreenshooterNamespaceData;

package/build/src/browser/client-scripts/screen-shooter/tsc-out/client-scripts/screen-shooter/utils/element-rect.js

@@ -0,0 +1,183 @@
+"use strict";
+exports.__esModule = true;
+exports.getVerticalRadiusInsets = exports.getPseudoElementCaptureRect = exports.getElementCaptureRect = exports.getBoundingClientContentRect = exports.getExtRect = exports.domRectToViewportCss = void 0;
+var _isomorphic_1 = require("@isomorphic");
+var dom_1 = require("./dom");
+var pseudo_element_rect_1 = require("./pseudo-element-rect");
+function domRectToViewportCss(domRect) {
+    return {
+        top: domRect.top,
+        left: domRect.left,
+        width: domRect.width,
+        height: domRect.height
+    };
+}
+exports.domRectToViewportCss = domRectToViewportCss;
+function getElementBorderWidths(element) {
+    var ownerWindow = (0, dom_1.getOwnerWindow)(element) || window;
+    var style = ownerWindow.getComputedStyle(element);
+    return {
+        top: parseFloat(style.borderTopWidth),
+        left: parseFloat(style.borderLeftWidth)
+    };
+}
+function getIframeContentOrigin(node) {
+    var border = getElementBorderWidths(node);
+    var bcr = node.getBoundingClientRect();
+    return {
+        top: (bcr.top + border.top),
+        left: (bcr.left + border.left),
+        width: bcr.width,
+        height: bcr.height
+    };
+}
+function getNestedBoundingClientRect(node, logger) {
+    var ownerIframe = (0, dom_1.getOwnerIframe)(node);
+    if (ownerIframe === null || (0, dom_1.getOwnerWindow)(ownerIframe) === window) {
+        logger === null || logger === void 0 ? void 0 : logger("getNestedBoundingClientRect ownerIframe is null or window, returning bounding rect untouched");
+        return domRectToViewportCss(node.getBoundingClientRect());
+    }
+    logger === null || logger === void 0 ? void 0 : logger("getNestedBoundingClientRect ownerIframe is not null or window, returning bounding rect with iframe origin");
+    var elementRect = domRectToViewportCss(node.getBoundingClientRect());
+    var top = elementRect.top;
+    var left = elementRect.left;
+    var currentIframe = ownerIframe;
+    while (currentIframe) {
+        var iframeOrigin = getIframeContentOrigin(currentIframe);
+        top += iframeOrigin.top;
+        left += iframeOrigin.left;
+        currentIframe = (0, dom_1.getOwnerIframe)(currentIframe);
+        if (currentIframe && (0, dom_1.getOwnerWindow)(currentIframe) === window) {
+            var outerOrigin = getIframeContentOrigin(currentIframe);
+            top += outerOrigin.top;
+            left += outerOrigin.left;
+            break;
+        }
+    }
+    return {
+        top: top,
+        left: left,
+        width: elementRect.width,
+        height: elementRect.height
+    };
+}
+function parseBoxShadow(value) {
+    var regex = /[-+]?\d*\.?\d+px/g;
+    var results = [];
+    for (var _i = 0, _a = (value || "").split(","); _i < _a.length; _i++) {
+        var part = _a[_i];
+        var match = part.match(regex);
+        if (match) {
+            results.push({
+                offsetX: parseFloat(match[0]),
+                offsetY: parseFloat(match[1]) || 0,
+                blurRadius: parseFloat(match[2]) || 0,
+                spreadRadius: parseFloat(match[3]) || 0,
+                inset: part.indexOf("inset") !== -1
+            });
+        }
+    }
+    return results;
+}
+function calculateShadowExtent(shadows) {
+    var result = { top: 0, left: 0, right: 0, bottom: 0 };
+    for (var _i = 0, shadows_1 = shadows; _i < shadows_1.length; _i++) {
+        var shadow = shadows_1[_i];
+        if (shadow.inset)
+            continue;
+        var blurAndSpread = shadow.spreadRadius + shadow.blurRadius;
+        result.left = Math.min(shadow.offsetX - blurAndSpread, result.left);
+        result.right = Math.max(shadow.offsetX + blurAndSpread, result.right);
+        result.top = Math.min(shadow.offsetY - blurAndSpread, result.top);
+        result.bottom = Math.max(shadow.offsetY + blurAndSpread, result.bottom);
+    }
+    return result;
+}
+function calculateShadowRect(clientRect, shadows) {
+    var extent = calculateShadowExtent(shadows);
+    return {
+        left: (clientRect.left + extent.left),
+        top: (clientRect.top + extent.top),
+        width: (clientRect.width - extent.left + extent.right),
+        height: (clientRect.height - extent.top + extent.bottom)
+    };
+}
+function calculateOutlineRect(clientRect, outline) {
+    return {
+        top: (clientRect.top - outline),
+        left: (clientRect.left - outline),
+        width: (clientRect.width + outline * 2),
+        height: (clientRect.height + outline * 2)
+    };
+}
+function getExtRect(css, clientRect) {
+    var shadows = parseBoxShadow(css.boxShadow);
+    var outlineWidth = parseInt(css.outlineWidth, 10);
+    var outline = !isNaN(outlineWidth) && css.outlineStyle !== "none" ? outlineWidth : 0;
+    return (0, _isomorphic_1.getCoveringRect)([calculateShadowRect(clientRect, shadows), calculateOutlineRect(clientRect, outline)]);
+}
+exports.getExtRect = getExtRect;
+function isHidden(css, rect) {
+    return (css.display === "none" ||
+        css.visibility === "hidden" ||
+        parseFloat(css.opacity) < 0.0001 ||
+        rect.width < 0.0001 ||
+        rect.height < 0.0001);
+}
+function getBoundingClientContentRect(element) {
+    var style = getComputedStyle(element);
+    var bcr = element.getBoundingClientRect();
+    var borderLeft = parseFloat(style.borderLeftWidth) || 0;
+    var borderTop = parseFloat(style.borderTopWidth) || 0;
+    var borderRight = parseFloat(style.borderRightWidth) || 0;
+    var borderBottom = parseFloat(style.borderBottomWidth) || 0;
+    return {
+        left: (bcr.left + borderLeft),
+        top: (bcr.top + borderTop),
+        width: (bcr.width - borderLeft - borderRight),
+        height: (bcr.height - borderTop - borderBottom)
+    };
+}
+exports.getBoundingClientContentRect = getBoundingClientContentRect;
+function getElementCaptureRect(element, logger) {
+    var css = getComputedStyle(element);
+    var clientRect = getNestedBoundingClientRect(element, logger);
+    logger === null || logger === void 0 ? void 0 : logger("getElementCaptureRect clientRect:", clientRect);
+    if (isHidden(css, clientRect)) {
+        return null;
+    }
+    var elementRect = getExtRect(css, clientRect);
+    for (var _i = 0, PSEUDO_ELEMENTS_1 = pseudo_element_rect_1.PSEUDO_ELEMENTS; _i < PSEUDO_ELEMENTS_1.length; _i++) {
+        var pseudoElement = PSEUDO_ELEMENTS_1[_i];
+        var pseudoCss = getComputedStyle(element, pseudoElement);
+        elementRect = (0, _isomorphic_1.getCoveringRect)([elementRect, getExtRect(pseudoCss, clientRect)]);
+    }
+    return elementRect;
+}
+exports.getElementCaptureRect = getElementCaptureRect;
+function getPseudoElementCaptureRect(element, pseudo) {
+    var css = getComputedStyle(element);
+    var clientRect = getNestedBoundingClientRect(element);
+    if (isHidden(css, clientRect)) {
+        return null;
+    }
+    var pseudoRect = (0, pseudo_element_rect_1.getPseudoElementRect)(element, pseudo, clientRect);
+    if (!pseudoRect) {
+        return null;
+    }
+    return getExtRect(getComputedStyle(element, pseudo), pseudoRect);
+}
+exports.getPseudoElementCaptureRect = getPseudoElementCaptureRect;
+function parseBorderRadius(value) {
+    var _a = value.trim().split(/\s+/), first = _a[0], second = _a[1];
+    var parsed = parseFloat(second !== null && second !== void 0 ? second : first);
+    return isNaN(parsed) ? 0 : parsed;
+}
+function getVerticalRadiusInsets(element) {
+    var style = getComputedStyle(element);
+    return {
+        top: Math.max(parseBorderRadius(style.borderTopLeftRadius), parseBorderRadius(style.borderTopRightRadius)),
+        bottom: Math.max(parseBorderRadius(style.borderBottomLeftRadius), parseBorderRadius(style.borderBottomRightRadius))
+    };
+}
+exports.getVerticalRadiusInsets = getVerticalRadiusInsets;

package/build/src/browser/client-scripts/screen-shooter/tsc-out/client-scripts/screen-shooter/utils/pseudo-element-rect.js

@@ -0,0 +1,205 @@
+"use strict";
+exports.__esModule = true;
+exports.getPseudoElementRect = exports.parseCaptureSelector = exports.PSEUDO_ELEMENTS = void 0;
+exports.PSEUDO_ELEMENTS = ["::before", "::after"];
+var PSEUDO_SELECTOR_REGEXP = /(.*?)(::before|::after)\s*$/i;
+function parseCaptureSelector(selector) {
+    var match = selector.match(PSEUDO_SELECTOR_REGEXP);
+    if (!match) {
+        return { elementSelector: selector, pseudoElement: null };
+    }
+    var elementSelector = match[1].trim();
+    if (!elementSelector) {
+        return { elementSelector: selector, pseudoElement: null };
+    }
+    return {
+        elementSelector: elementSelector,
+        pseudoElement: match[2].toLowerCase()
+    };
+}
+exports.parseCaptureSelector = parseCaptureSelector;
+function getElementBorderWidths(element) {
+    var style = getComputedStyle(element);
+    return {
+        top: parseFloat(style.borderTopWidth),
+        left: parseFloat(style.borderLeftWidth)
+    };
+}
+function parseLengthOrZero(value) {
+    var parsed = parseFloat(value);
+    return isNaN(parsed) ? 0 : parsed;
+}
+function getElementContentBottom(element) {
+    var range = document.createRange();
+    try {
+        range.selectNodeContents(element);
+        var rects = range.getClientRects();
+        var bottom = -Infinity;
+        for (var i = 0; i < rects.length; i++) {
+            var rect = rects[i];
+            if (rect.width < 0.0001 && rect.height < 0.0001) {
+                continue;
+            }
+            bottom = Math.max(bottom, rect.bottom);
+        }
+        return bottom !== -Infinity ? bottom : null;
+    }
+    catch (_a) {
+        return null;
+    }
+    finally {
+        if (typeof range.detach === "function") {
+            range.detach();
+        }
+    }
+}
+function getContainingBlockPaddingEdge(element) {
+    var current = element.parentElement;
+    while (current) {
+        var pos = getComputedStyle(current).position;
+        if (pos !== "static") {
+            var bcr = current.getBoundingClientRect();
+            var borders = getElementBorderWidths(current);
+            return {
+                top: bcr.top + borders.top,
+                left: bcr.left + borders.left
+            };
+        }
+        current = current.parentElement;
+    }
+    return null; // initial containing block = viewport
+}
+function parseTransformMatrix(transform) {
+    if (!transform || transform === "none")
+        return null;
+    var match2d = transform.match(/matrix\(([^)]+)\)/);
+    if (match2d) {
+        var v = match2d[1].split(",").map(function (s) { return parseFloat(s.trim()); });
+        return { a: v[0], b: v[1], c: v[2], d: v[3], tx: v[4], ty: v[5] };
+    }
+    var match3d = transform.match(/matrix3d\(([^)]+)\)/);
+    if (match3d) {
+        var v = match3d[1].split(",").map(function (s) { return parseFloat(s.trim()); });
+        return { a: v[0], b: v[1], c: v[4], d: v[5], tx: v[12], ty: v[13] };
+    }
+    return null;
+}
+function resolveTransformOrigin(originStr, width, height) {
+    var parts = originStr.split(/\s+/);
+    function resolve(val, size) {
+        if (val.slice(-1) === "%") {
+            return (parseFloat(val) / 100) * size;
+        }
+        return parseFloat(val) || 0;
+    }
+    return {
+        x: resolve(parts[0], width),
+        y: resolve(parts[1] || parts[0], height)
+    };
+}
+function applyTransformToRect(rect, css) {
+    var matrix = parseTransformMatrix(css.transform);
+    if (!matrix)
+        return rect;
+    var transformOrigin = resolveTransformOrigin(css.transformOrigin, rect.width, rect.height);
+    var originX = rect.left + transformOrigin.x;
+    var originY = rect.top + transformOrigin.y;
+    var corners = [
+        [rect.left, rect.top],
+        [rect.left + rect.width, rect.top],
+        [rect.left, rect.top + rect.height],
+        [rect.left + rect.width, rect.top + rect.height]
+    ];
+    var minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+    for (var _i = 0, corners_1 = corners; _i < corners_1.length; _i++) {
+        var _a = corners_1[_i], cornerX = _a[0], cornerY = _a[1];
+        var relativeX = cornerX - originX, relativeY = cornerY - originY;
+        var transformedX = matrix.a * relativeX + matrix.c * relativeY + matrix.tx + originX;
+        var transformedY = matrix.b * relativeX + matrix.d * relativeY + matrix.ty + originY;
+        minX = Math.min(minX, transformedX);
+        maxX = Math.max(maxX, transformedX);
+        minY = Math.min(minY, transformedY);
+        maxY = Math.max(maxY, transformedY);
+    }
+    return {
+        left: minX,
+        top: minY,
+        width: (maxX - minX),
+        height: (maxY - minY)
+    };
+}
+function computeBaseRect(element, pseudo, css, elementRect) {
+    var width = parseFloat(css.width);
+    var height = parseFloat(css.height);
+    if (isNaN(width) || isNaN(height) || width < 0.0001 || height < 0.0001) {
+        return null;
+    }
+    var position = css.position;
+    if (position === "fixed") {
+        var top_1 = parseFloat(css.top);
+        var left = parseFloat(css.left);
+        return {
+            top: (isNaN(top_1) ? 0 : top_1),
+            left: (isNaN(left) ? 0 : left),
+            width: width,
+            height: height
+        };
+    }
+    if (position === "absolute") {
+        var elementCss_1 = getComputedStyle(element);
+        var originTop = void 0;
+        var originLeft = void 0;
+        if (elementCss_1.position !== "static") {
+            var borders = getElementBorderWidths(element);
+            originTop = elementRect.top + borders.top;
+            originLeft = elementRect.left + borders.left;
+        }
+        else {
+            var containingBlock = getContainingBlockPaddingEdge(element);
+            originTop = containingBlock ? containingBlock.top : 0;
+            originLeft = containingBlock ? containingBlock.left : 0;
+        }
+        var top_2 = parseFloat(css.top);
+        var left = parseFloat(css.left);
+        return {
+            top: (originTop + (isNaN(top_2) ? 0 : top_2)),
+            left: (originLeft + (isNaN(left) ? 0 : left)),
+            width: width,
+            height: height
+        };
+    }
+    var elementCss = getComputedStyle(element);
+    var borderTop = parseLengthOrZero(elementCss.borderTopWidth);
+    var borderLeft = parseLengthOrZero(elementCss.borderLeftWidth);
+    var paddingTop = parseLengthOrZero(elementCss.paddingTop);
+    var paddingLeft = parseLengthOrZero(elementCss.paddingLeft);
+    var marginTop = parseLengthOrZero(css.marginTop);
+    var marginLeft = parseLengthOrZero(css.marginLeft);
+    var relativeTop = position === "relative" ? parseLengthOrZero(css.top) : 0;
+    var relativeLeft = position === "relative" ? parseLengthOrZero(css.left) : 0;
+    var flowTop = elementRect.top + borderTop + paddingTop;
+    if (pseudo === "::after" && css.display === "block") {
+        var contentBottom = getElementContentBottom(element);
+        if (contentBottom !== null) {
+            flowTop = Math.max(flowTop, contentBottom);
+        }
+    }
+    // In-flow pseudo-element: anchor at the element content box and apply pseudo margins
+    return {
+        top: (flowTop + marginTop + relativeTop),
+        left: (elementRect.left + borderLeft + paddingLeft + marginLeft + relativeLeft),
+        width: width,
+        height: height
+    };
+}
+function getPseudoElementRect(element, pseudo, elementRect) {
+    var css = getComputedStyle(element, pseudo);
+    if (css.content === "none" || css.display === "none" || css.visibility === "hidden") {
+        return null;
+    }
+    var baseRect = computeBaseRect(element, pseudo, css, elementRect);
+    if (!baseRect)
+        return null;
+    return applyTransformToRect(baseRect, css);
+}
+exports.getPseudoElementRect = getPseudoElementRect;