@mablhq/playwright-tools 2.49.1

package/browserLauncher/playwrightBrowserLauncher/playwrightDom.js

@@ -0,0 +1,319 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PlaywrightElementHandle = exports.PlaywrightJsHandle = exports.NAVIGATION_ERROR_MESSAGE = void 0;
+const playwright = __importStar(require("playwright"));
+const types_1 = require("../types");
+const utils_1 = require("../utils");
+const logUtils_1 = require("../../util/logUtils");
+const pureUtil_1 = require("../../util/pureUtil");
+exports.NAVIGATION_ERROR_MESSAGE = 'waiting for scheduled navigations to finish';
+class PlaywrightJsHandle {
+    constructor(handle, page) {
+        this.handle = handle;
+        this.page = page;
+    }
+    getPlaywrightHandle() {
+        return this.handle;
+    }
+    asElement() {
+        return undefined;
+    }
+    evaluate(pageFunction, arg) {
+        return this.handle.evaluate(pageFunction, PlaywrightJsHandle.unwrapProperties(arg));
+    }
+    async evaluateHandle(code, arg) {
+        const handle = await this.handle.evaluateHandle(code, PlaywrightJsHandle.unwrapProperties(arg));
+        return (0, utils_1.mapIfNotNull)(handle, (handle) => handle.asElement()
+            ? new PlaywrightElementHandle(handle.asElement(), this.page, this.page.delegate.createElementHandleDelegate(handle.asElement()))
+            : new PlaywrightJsHandle(handle, this.page));
+    }
+    async getProperty(propertyName) {
+        return (0, utils_1.mapIfNotNull)(await this.handle.getProperty(propertyName), (handle) => new PlaywrightJsHandle(handle, this.page));
+    }
+    jsonValue() {
+        return this.handle.jsonValue();
+    }
+    isContextDestroyed() {
+        var _a, _b;
+        const elementImpl = playwright._toImpl(this.handle);
+        return !!((_b = (_a = elementImpl._context) === null || _a === void 0 ? void 0 : _a._contextDestroyedScope) === null || _b === void 0 ? void 0 : _b.isClosed());
+    }
+    static unwrapProperties(arg, addSecondaryWorldFlag = false) {
+        if (arg === undefined) {
+            return addSecondaryWorldFlag ? { secondaryWorldValue: undefined } : null;
+        }
+        if (addSecondaryWorldFlag && arg instanceof PlaywrightJsHandle) {
+            throw new Error('Unable to setup the secondary world if the argument is a JsHandle. Pass an object instead');
+        }
+        let result = arg;
+        if (arg instanceof PlaywrightJsHandle) {
+            result = arg.getPlaywrightHandle();
+        }
+        else if ((typeof arg !== 'object' || Array.isArray(arg)) &&
+            !addSecondaryWorldFlag) {
+            result = arg;
+        }
+        else if (typeof arg === 'object' &&
+            !Object.keys(arg).some((key) => arg[key] instanceof PlaywrightJsHandle)) {
+            result = arg;
+        }
+        else if (typeof arg === 'object' && !Array.isArray(arg)) {
+            const unwrapped = { ...arg };
+            Object.keys(arg).forEach((propertyName) => {
+                const propertyValue = unwrapped[propertyName];
+                if (propertyValue instanceof PlaywrightJsHandle) {
+                    unwrapped[propertyName] = propertyValue.getPlaywrightHandle();
+                }
+            });
+            result = unwrapped;
+        }
+        return addSecondaryWorldFlag ? { secondaryWorldValue: result } : result;
+    }
+}
+exports.PlaywrightJsHandle = PlaywrightJsHandle;
+class PlaywrightElementHandle extends PlaywrightJsHandle {
+    constructor(element, page, delegate) {
+        super(element, page);
+        this.element = element;
+        this.page = page;
+        this.delegate = delegate;
+        try {
+            this.cdpSession = delegate.getCDPSession();
+        }
+        catch (e) {
+            (0, logUtils_1.logInternal)(`Unable to get a CDP session for the element handle. Error: ${e}`);
+        }
+    }
+    uploadFile(filePath) {
+        return this.element.setInputFiles(filePath);
+    }
+    async $x(xpathQuery) {
+        return (await this.element.$$(`xpath=${xpathQuery}`)).map((element) => new PlaywrightElementHandle(element, this.page, this.page.delegate.createElementHandleDelegate(element)));
+    }
+    asElement() {
+        return (0, utils_1.mapIfNotNull)(this.handle.asElement(), (handle) => new PlaywrightElementHandle(handle, this.page, this.page.delegate.createElementHandleDelegate(handle)));
+    }
+    async boundingBox() {
+        return (0, utils_1.mapIfNotNull)(await this.element.boundingBox(), (boundingBox) => boundingBox);
+    }
+    async maybeOverwriteScrollIntoViewDuringAction(action, options) {
+        if (options === null || options === void 0 ? void 0 : options.minimizeScrollIntoView) {
+            await this.overwriteScrollIntoViewFunction();
+        }
+        try {
+            return await action();
+        }
+        catch (e) {
+            throw e;
+        }
+        finally {
+            if (options === null || options === void 0 ? void 0 : options.minimizeScrollIntoView) {
+                await this.resetScrollIntoViewFunction();
+            }
+        }
+    }
+    click(options) {
+        return this.maybeOverwriteScrollIntoViewDuringAction(async () => {
+            var _a, _b, _c;
+            const trial = (_a = options === null || options === void 0 ? void 0 : options.trial) !== null && _a !== void 0 ? _a : false;
+            try {
+                await this.element.click({
+                    button: options === null || options === void 0 ? void 0 : options.button,
+                    clickCount: (_b = options === null || options === void 0 ? void 0 : options.clickCount) !== null && _b !== void 0 ? _b : 1,
+                    force: (_c = options === null || options === void 0 ? void 0 : options.force) !== null && _c !== void 0 ? _c : !trial,
+                    timeout: this.getActionTimeout(options),
+                    trial,
+                });
+            }
+            catch (error) {
+                if (error.message.includes(exports.NAVIGATION_ERROR_MESSAGE)) {
+                    (0, logUtils_1.logInternal)(`Action timed out due to navigation timeout. ${error.toString()}`);
+                    return;
+                }
+                throw error;
+            }
+        }, {
+            minimizeScrollIntoView: options === null || options === void 0 ? void 0 : options.minimizeScrollIntoView,
+        });
+    }
+    async doubleClick(options) {
+        return this.maybeOverwriteScrollIntoViewDuringAction(async () => {
+            var _a, _b;
+            try {
+                const trial = (_a = options === null || options === void 0 ? void 0 : options.trial) !== null && _a !== void 0 ? _a : false;
+                return this.element.dblclick({
+                    force: (_b = options === null || options === void 0 ? void 0 : options.force) !== null && _b !== void 0 ? _b : !trial,
+                    timeout: this.getActionTimeout(options),
+                    trial,
+                });
+            }
+            catch (error) {
+                if (error.message.includes(exports.NAVIGATION_ERROR_MESSAGE)) {
+                    (0, logUtils_1.logInternal)(`Action timed out due to navigation timeout. ${error.toString()}`);
+                }
+            }
+        }, {
+            minimizeScrollIntoView: options === null || options === void 0 ? void 0 : options.minimizeScrollIntoView,
+        });
+    }
+    async clickablePoint() {
+        var _a;
+        const clickablePoint = await ((_a = this.delegate
+            .getElementImpl()) === null || _a === void 0 ? void 0 : _a._clickablePoint());
+        if (clickablePoint === 'error:notvisible' ||
+            clickablePoint === 'error:notinviewport') {
+            return undefined;
+        }
+        return clickablePoint;
+    }
+    async contentFrame() {
+        return (0, utils_1.mapIfNotNull)(await this.element.contentFrame(), (frame) => this.page.getOrCreateFrame(frame));
+    }
+    focus() {
+        return this.element.focus();
+    }
+    async frame() {
+        return (0, utils_1.mapIfNotNull)(await this.element.ownerFrame(), (frame) => this.page.getOrCreateFrame(frame));
+    }
+    hover() {
+        return this.element.hover();
+    }
+    scrollIntoViewIfNeeded() {
+        return this.element.scrollIntoViewIfNeeded();
+    }
+    async select(value, options) {
+        return this.maybeOverwriteScrollIntoViewDuringAction(async () => this.element.selectOption(value), {
+            minimizeScrollIntoView: options === null || options === void 0 ? void 0 : options.minimizeScrollIntoView,
+        });
+    }
+    async type(text, options) {
+        return this.maybeOverwriteScrollIntoViewDuringAction(async () => {
+            var _a;
+            const selectText = (_a = options === null || options === void 0 ? void 0 : options.selectText) !== null && _a !== void 0 ? _a : true;
+            if (selectText) {
+                await this.element.selectText({ force: true });
+            }
+            await this.element.type(text, {
+                delay: options === null || options === void 0 ? void 0 : options.delay,
+                timeout: 0,
+            });
+        }, {
+            minimizeScrollIntoView: options === null || options === void 0 ? void 0 : options.minimizeScrollIntoView,
+        });
+    }
+    press(key, options) {
+        return this.maybeOverwriteScrollIntoViewDuringAction(async () => this.element.press(key), {
+            minimizeScrollIntoView: options === null || options === void 0 ? void 0 : options.minimizeScrollIntoView,
+        });
+    }
+    highlight(highlightDurationMillis, highlightPhases) {
+        return this.delegate.highlight(highlightDurationMillis, highlightPhases);
+    }
+    async getValue() {
+        return this.element.inputValue();
+    }
+    async makeCDPCall(method, paramArgs) {
+        var _a;
+        return ((_a = this.cdpSession) !== null && _a !== void 0 ? _a : this.page.getCDPSession()).send(method, paramArgs);
+    }
+    getTagName() {
+        return this.element.evaluate((el) => el.tagName.toLowerCase());
+    }
+    async getAttribute(attributeName) {
+        const result = await this.element.evaluate((el, attributeName) => el.getAttribute(attributeName), attributeName);
+        return (0, pureUtil_1.isNullish)(result) ? undefined : result;
+    }
+    async getCSSProperty(propertyName) {
+        const result = await this.element.evaluate((el, propertyName) => globalThis.getComputedStyle(el).getPropertyValue(propertyName), propertyName);
+        return (0, pureUtil_1.isNullish)(result) ? undefined : result;
+    }
+    async getElementText() {
+        const innerText = await this.getInnerText();
+        return innerText ? innerText : this.getSlotText();
+    }
+    async getInnerText() {
+        const result = await this.delegate.getInnerText();
+        return (0, pureUtil_1.isNullish)(result) ? undefined : result;
+    }
+    async getSlotText() {
+        const result = await this.element.evaluate((el) => {
+            const slots = el.querySelectorAll('slot');
+            if (slots.length !== 1) {
+                return '';
+            }
+            const textNode = slots
+                .item(0)
+                .assignedNodes()
+                .find((node) => node.nodeType === Node.TEXT_NODE);
+            return textNode === null || textNode === void 0 ? void 0 : textNode.data;
+        });
+        return (0, pureUtil_1.isNullish)(result) ? undefined : result;
+    }
+    async isInShadowRoot() {
+        return this.element.evaluate((el) => el.getRootNode().nodeName === '#document-fragment');
+    }
+    focusAndSelect() {
+        return this.delegate.focusAndSelect(this);
+    }
+    async isVisible() {
+        return this.element.isVisible();
+    }
+    getActionTimeout(options) {
+        var _a;
+        const defaultTimeout = (options === null || options === void 0 ? void 0 : options.trial)
+            ? types_1.DefaultTimeouts.defaultTrialTimeoutMs
+            : types_1.DefaultTimeouts.defaultActionTimeoutMs;
+        return (_a = options === null || options === void 0 ? void 0 : options.timeout) !== null && _a !== void 0 ? _a : defaultTimeout;
+    }
+    async overwriteScrollIntoViewFunction() {
+        var _a;
+        await ((_a = this.delegate
+            .getElementImpl()) === null || _a === void 0 ? void 0 : _a.evaluateInUtility(([, node]) => {
+            const element = node;
+            if (!element.__mablOriginalScrollIntoView) {
+                element.__mablOriginalScrollIntoView = element.scrollIntoView;
+            }
+            element.scrollIntoView = () => element.scrollIntoViewIfNeeded();
+        }, []));
+    }
+    async resetScrollIntoViewFunction() {
+        var _a;
+        try {
+            await ((_a = this.delegate
+                .getElementImpl()) === null || _a === void 0 ? void 0 : _a.evaluateInUtility(([, node]) => {
+                const element = node;
+                const originalFunction = element.__mablOriginalScrollIntoView;
+                if (originalFunction) {
+                    element.scrollIntoView = originalFunction;
+                }
+            }, []));
+        }
+        catch (error) {
+            (0, logUtils_1.logInternal)(`Error while resetting scrollIntoView function: ${error}`);
+        }
+    }
+}
+exports.PlaywrightElementHandle = PlaywrightElementHandle;

package/browserLauncher/playwrightBrowserLauncher/playwrightFrame.js

@@ -0,0 +1,265 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PlaywrightFrame = exports.UTILITY_CONTEXT_NAME = void 0;
+const browserLauncher_1 = require("../browserLauncher");
+const playwright = __importStar(require("playwright"));
+const types_1 = require("../types");
+const utils_1 = require("../utils");
+const playwrightHttpResponse_1 = require("./playwrightHttpResponse");
+const playwrightDom_1 = require("./playwrightDom");
+const testsUtil_1 = require("../../commands/tests/testsUtil");
+const logUtils_1 = require("../../util/logUtils");
+const WAIT_FOR_CONTEXT_TIMEOUT = 1000;
+const MAIN_CONTEXT = 'main';
+const UTILITY_CONTEXT = 'utility';
+exports.UTILITY_CONTEXT_NAME = '__playwright_utility_world__';
+class PlaywrightFrame extends browserLauncher_1.Frame {
+    constructor(frame, parentPage, delegate) {
+        super();
+        this.frame = frame;
+        this.parentPage = parentPage;
+        this.delegate = delegate;
+        this.injectSecondaryWorld();
+    }
+    injectSecondaryWorld() {
+        const playwrightFrame = this;
+        const serverFrame = this.getFrameImpl();
+        if (serverFrame === undefined) {
+            return;
+        }
+        const originalSetContext = serverFrame._setContext.bind(serverFrame);
+        serverFrame._setContext = function (world, context) {
+            originalSetContext(world, context);
+            if (world === UTILITY_CONTEXT) {
+                playwrightFrame.emit(browserLauncher_1.PageEvent.SecondaryWorldCreated);
+            }
+        };
+        serverFrame.checkWorldFunction = async function (arg) {
+            let forcedWorld = MAIN_CONTEXT;
+            if (this.utilityWorldAvailable === undefined) {
+                await Promise.race([
+                    this._contextData.get(UTILITY_CONTEXT).contextPromise,
+                    (0, testsUtil_1.sleep)(WAIT_FOR_CONTEXT_TIMEOUT),
+                ]);
+                this.utilityWorldAvailable =
+                    this._contextData.get(UTILITY_CONTEXT).context !== null;
+            }
+            if (arg === null || arg === void 0 ? void 0 : arg.hasOwnProperty('secondaryWorldValue')) {
+                forcedWorld = UTILITY_CONTEXT;
+                if (!this.utilityWorldAvailable) {
+                    this._contextData.set(UTILITY_CONTEXT, this._contextData.get(MAIN_CONTEXT));
+                    this.utilityWorldAvailable = true;
+                }
+                arg = arg.secondaryWorldValue;
+            }
+            return { world: forcedWorld, value: arg };
+        };
+        const originalEvaluateExpressionFunction = serverFrame.evaluateExpression.bind(serverFrame);
+        const functionOverride = async function (expression, options = {}, arg) {
+            const { world, value } = await this.checkWorldFunction(arg);
+            return originalEvaluateExpressionFunction(expression, {
+                isFunction: options.isFunction,
+                exposeUtilityScript: options.exposeUtilityScript,
+                world,
+            }, value);
+        };
+        serverFrame.evaluateExpression = functionOverride.bind(serverFrame);
+        const originalEvaluateExpressionHandleFunction = serverFrame.evaluateExpressionHandle.bind(serverFrame);
+        const functionHandleOverride = async function (expression, options = {}, arg) {
+            const { world, value } = await this.checkWorldFunction(arg);
+            return originalEvaluateExpressionHandleFunction(expression, {
+                isFunction: options.isFunction,
+                exposeUtilityScript: options.exposeUtilityScript,
+                world,
+            }, value);
+        };
+        serverFrame.evaluateExpressionHandle =
+            functionHandleOverride.bind(serverFrame);
+    }
+    async $(selector) {
+        return (0, utils_1.mapIfNotNull)(await this.frame.$(selector), (handle) => new playwrightDom_1.PlaywrightElementHandle(handle, this.parentPage, this.parentPage.delegate.createElementHandleDelegate(handle)));
+    }
+    async $$(selector) {
+        const maybePlaywrightHandles = await this.frame.$$(selector);
+        if (!maybePlaywrightHandles.length) {
+            return [];
+        }
+        return maybePlaywrightHandles.map((handle) => new playwrightDom_1.PlaywrightElementHandle(handle, this.parentPage, this.parentPage.delegate.createElementHandleDelegate(handle)));
+    }
+    async $$eval(selector, pageFunction, ...args) {
+        const result = await this.frame.$$eval(selector, pageFunction, ...args === null || args === void 0 ? void 0 : args.map((argument) => argument instanceof playwrightDom_1.PlaywrightJsHandle
+            ? argument.getPlaywrightHandle()
+            : argument));
+        return result;
+    }
+    async $eval(selector, pageFunction, ...args) {
+        const result = await this.frame.$eval(selector, pageFunction, ...args === null || args === void 0 ? void 0 : args.map((argument) => argument instanceof playwrightDom_1.PlaywrightJsHandle
+            ? argument.getPlaywrightHandle()
+            : argument));
+        return result;
+    }
+    async $x(xpathQuery) {
+        return (await this.frame.$$(`xpath=${xpathQuery}`)).map((element) => new playwrightDom_1.PlaywrightElementHandle(element, this.parentPage, this.parentPage.delegate.createElementHandleDelegate(element)));
+    }
+    childFrames() {
+        return this.frame
+            .childFrames()
+            .map((frame) => this.parentPage.getOrCreateFrame(frame));
+    }
+    evaluate(pageFunction, arg, addSecondaryWorldFlag = false) {
+        return this.frame.evaluate(pageFunction, playwrightDom_1.PlaywrightJsHandle.unwrapProperties(arg, addSecondaryWorldFlag));
+    }
+    async evaluateCodeInSecondaryWorld(code, arg) {
+        return (await this.evaluate(code, arg, true));
+    }
+    async evaluateHandleInSecondaryWorld(code, arg) {
+        return new playwrightDom_1.PlaywrightJsHandle(await this.frame.evaluateHandle(code, playwrightDom_1.PlaywrightJsHandle.unwrapProperties(arg, true)), this.parentPage);
+    }
+    async getFrameOwnerElement() {
+        const frameElement = await this.frame.frameElement();
+        return new playwrightDom_1.PlaywrightElementHandle(frameElement, this.parentPage, this.parentPage.delegate.createElementHandleDelegate(frameElement));
+    }
+    async goto(url, options) {
+        const lifecycleEvent = this.delegate.getLifecycleEventStrategy(options === null || options === void 0 ? void 0 : options.waitUntil);
+        try {
+            return await this.tryGoto(url, lifecycleEvent, options);
+        }
+        catch (e) {
+            (0, logUtils_1.logErrorVerbose)(e);
+            if (e instanceof playwright.errors.TimeoutError) {
+                throw new browserLauncher_1.RUNNER_ERRORS.TimeoutError(e.message);
+            }
+            throw new browserLauncher_1.RunnerError(e.message);
+        }
+    }
+    async tryGoto(url, lifecycleEvent, options) {
+        var _a;
+        const timeout = (_a = options === null || options === void 0 ? void 0 : options.timeout) !== null && _a !== void 0 ? _a : types_1.DefaultTimeouts.defaultWaitTimeoutMs;
+        let response;
+        let responseHasNavigationError = false;
+        try {
+            response = await this.frame.goto(url, {
+                waitUntil: lifecycleEvent.waitUntil,
+                timeout: options === null || options === void 0 ? void 0 : options.timeout,
+            });
+        }
+        catch (e) {
+            if (browserLauncher_1.RunnerError.isPlaywrightNavigationInterruptedError(e)) {
+                (0, logUtils_1.logErrorVerbose)(e);
+                responseHasNavigationError = true;
+            }
+            else {
+                throw e;
+            }
+        }
+        if (lifecycleEvent.waitForNetworkIdle || responseHasNavigationError) {
+            await this.frame.waitForLoadState(types_1.LifecycleEvent.NetworkIdle, {
+                timeout,
+            });
+        }
+        return (0, utils_1.mapIfNotNull)(response, (response) => new playwrightHttpResponse_1.PlaywrightHttpResponse(this.parentPage, response));
+    }
+    id() {
+        return this.frame._guid;
+    }
+    name() {
+        return this.frame.name();
+    }
+    parentFrame() {
+        return (0, utils_1.mapIfNotNull)(this.frame.parentFrame(), (frame) => this.parentPage.getOrCreateFrame(frame));
+    }
+    url() {
+        return this.delegate.url();
+    }
+    async waitForSelector(selector, options) {
+        return (0, utils_1.mapIfNotNull)(await this.frame.waitForSelector(selector, options), (handle) => new playwrightDom_1.PlaywrightElementHandle(handle, this.parentPage, this.parentPage.delegate.createElementHandleDelegate(handle)));
+    }
+    page() {
+        return this.parentPage;
+    }
+    title() {
+        return this.frame.title();
+    }
+    makeCDPCall(method, paramArgs) {
+        const pageImpl = this.page().getPageImpl();
+        const frameSession = pageImpl._sessionForFrame(this.frame);
+        const client = frameSession._client;
+        return client.send(method, paramArgs);
+    }
+    getFrameImpl() {
+        if (this.frameImpl === undefined) {
+            try {
+                return playwright._toImpl(this.frame);
+            }
+            catch (e) {
+            }
+        }
+        return this.frameImpl;
+    }
+    getExposedFunctionBindingInfo(functionName) {
+        var _a;
+        try {
+            const pageImpl = this.parentPage.getPageImpl();
+            if (!pageImpl) {
+                return;
+            }
+            return ((_a = pageImpl._pageBindings.get(functionName)) !== null && _a !== void 0 ? _a : pageImpl._browserContext._pageBindings.get(functionName));
+        }
+        catch (e) {
+            return;
+        }
+    }
+    async initializeExposedFunctionInSecondaryWorld(functionName) {
+        try {
+            const binding = this.getExposedFunctionBindingInfo(functionName);
+            if (!binding) {
+                return false;
+            }
+            await this.delegate.addBindingToSecondaryWorld(binding);
+            await this.evaluateCodeInSecondaryWorld(binding.source, {});
+        }
+        catch (e) {
+            return false;
+        }
+        return true;
+    }
+    async getInjectedScriptInSecondaryWorld() {
+        const context = await this.getFrameImpl()._utilityContext();
+        return new playwrightDom_1.PlaywrightJsHandle(await context.injectedScript(), this.page());
+    }
+    async getInjectedScriptInMainWorld() {
+        const context = await this.getFrameImpl()._mainContext();
+        return new playwrightDom_1.PlaywrightJsHandle(await context.injectedScript(), this.page());
+    }
+    isDetached() {
+        return this.frame.isDetached();
+    }
+    async getOwnerElementHandle() {
+        const element = await this.frame.frameElement();
+        return new playwrightDom_1.PlaywrightElementHandle(element, this.parentPage, this.parentPage.delegate.createElementHandleDelegate(element));
+    }
+}
+exports.PlaywrightFrame = PlaywrightFrame;

package/browserLauncher/playwrightBrowserLauncher/playwrightHttpRequest.js

@@ -0,0 +1,76 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PlaywrightHttpRequest = void 0;
+const playwright = __importStar(require("playwright"));
+const logUtils_1 = require("../../util/logUtils");
+class PlaywrightHttpRequest {
+    constructor(page, request, route) {
+        var _a;
+        this.page = page;
+        this.request = request;
+        this.route = route;
+        this.requestIntercepted = false;
+        try {
+            this.documentId = playwright._toImpl(this.request)._documentId;
+        }
+        catch (e) {
+            (0, logUtils_1.logInternal)(`Unable to get documentId from request: ${e.message}`);
+        }
+        (_a = this.documentId) !== null && _a !== void 0 ? _a : (this.documentId = this.request._guid);
+    }
+    abort() {
+        var _a;
+        if (this.route === undefined) {
+            throw new Error('Unable to abort an unrouted request');
+        }
+        this.requestIntercepted = true;
+        return (_a = this.route) === null || _a === void 0 ? void 0 : _a.abort();
+    }
+    frame() {
+        return this.page.getOrCreateFrame(this.request.frame());
+    }
+    requestId() {
+        return this.documentId;
+    }
+    respond(response) {
+        var _a;
+        if (this.route === undefined) {
+            throw new Error('Unable to respond an unrouted request');
+        }
+        this.requestIntercepted = true;
+        return (_a = this.route) === null || _a === void 0 ? void 0 : _a.fulfill(response);
+    }
+    url() {
+        return this.request.url();
+    }
+    headers() {
+        return this.request.allHeaders();
+    }
+    wasIntercepted() {
+        return this.requestIntercepted;
+    }
+}
+exports.PlaywrightHttpRequest = PlaywrightHttpRequest;

package/browserLauncher/playwrightBrowserLauncher/playwrightHttpResponse.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PlaywrightHttpResponse = void 0;
+const playwrightHttpRequest_1 = require("./playwrightHttpRequest");
+class PlaywrightHttpResponse {
+    constructor(page, response) {
+        this.page = page;
+        this.response = response;
+    }
+    frame() {
+        return this.page.getOrCreateFrame(this.response.frame());
+    }
+    headers() {
+        return this.response.headers();
+    }
+    request() {
+        return new playwrightHttpRequest_1.PlaywrightHttpRequest(this.page, this.response.request());
+    }
+    url() {
+        return this.response.url();
+    }
+    json() {
+        return this.response.json();
+    }
+}
+exports.PlaywrightHttpResponse = PlaywrightHttpResponse;