@applitools/eyes 1.0.0

package/dist/Logger.js

@@ -0,0 +1,128 @@
+"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.Logger = void 0;
+const utils = __importStar(require("@applitools/utils"));
+const logger_1 = require("@applitools/logger");
+const LogHandler_1 = require("./input/LogHandler");
+class Logger {
+    _makeLogger() {
+        return (0, logger_1.makeLogger)({
+            handler: this._options.handler && this._options.handler instanceof LogHandler_1.LogHandlerData
+                ? this._options.handler.toJSON()
+                : this._options.handler,
+            level: this._options.show || utils.general.getEnvValue('SHOW_LOGS', 'boolean') ? 'info' : 'silent',
+            label: this._options.label,
+        });
+    }
+    constructor(loggerOrOptionsOrShow = false) {
+        this._options = {};
+        /** @internal */
+        this.isLogger = true;
+        if (utils.types.isBoolean(loggerOrOptionsOrShow)) {
+            return new Logger({ show: loggerOrOptionsOrShow });
+        }
+        else if (utils.types.has(loggerOrOptionsOrShow, ['log', 'console'])) {
+            this._logger = loggerOrOptionsOrShow;
+        }
+        else {
+            this._options = loggerOrOptionsOrShow;
+        }
+    }
+    /** @internal */
+    getLogger() {
+        if (!this._logger)
+            this._logger = this._makeLogger();
+        return this._logger;
+    }
+    getLogHandler() {
+        if (this._options.handler) {
+            if (!utils.types.has(this._options.handler, 'type')) {
+                return this._options.handler;
+            }
+            else if (this._options.handler.type === 'file') {
+                return new LogHandler_1.FileLogHandlerData(true, this._options.handler.filename, this._options.handler.append);
+            }
+            else if (this._options.handler.type === 'console') {
+                return new LogHandler_1.ConsoleLogHandlerData(true);
+            }
+        }
+        return new LogHandler_1.NullLogHandlerData();
+    }
+    setLogHandler(handler) {
+        this._options.handler = handler;
+        this._options.show = true;
+    }
+    verbose(...messages) {
+        if (!this._logger)
+            this._logger = this._makeLogger();
+        messages.forEach(message => this._logger.log(message));
+    }
+    log(...messages) {
+        if (!this._logger)
+            this._logger = this._makeLogger();
+        messages.forEach(message => this._logger.log(message));
+    }
+    warn(...messages) {
+        if (!this._logger)
+            this._logger = this._makeLogger();
+        messages.forEach(message => this._logger.warn(message));
+    }
+    error(...messages) {
+        if (!this._logger)
+            this._logger = this._makeLogger();
+        messages.forEach(message => this._logger.error(message));
+    }
+    fatal(...messages) {
+        if (!this._logger)
+            this._logger = this._makeLogger();
+        messages.forEach(message => this._logger.fatal(message));
+    }
+    open() {
+        var _a;
+        (_a = this._logger) === null || _a === void 0 ? void 0 : _a.open();
+    }
+    close() {
+        var _a;
+        (_a = this._logger) === null || _a === void 0 ? void 0 : _a.close();
+    }
+    tag(name, value) {
+        var _a;
+        (_a = this._logger) === null || _a === void 0 ? void 0 : _a.tag(name, value);
+    }
+    extend(optionsOrLabel) {
+        var _a;
+        if (utils.types.isString(optionsOrLabel))
+            return this.extend({ label: optionsOrLabel });
+        if (this._logger)
+            return new Logger(this._logger.extend(optionsOrLabel));
+        return new Logger({
+            show: this._options.show,
+            label: (_a = optionsOrLabel === null || optionsOrLabel === void 0 ? void 0 : optionsOrLabel.label) !== null && _a !== void 0 ? _a : this._options.label,
+            handler: this._options.handler,
+        });
+    }
+}
+exports.Logger = Logger;

package/dist/Runners.js

@@ -0,0 +1,126 @@
+"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.ClassicRunner = exports.VisualGridRunner = exports.EyesRunner = void 0;
+const NewTestError_1 = require("./errors/NewTestError");
+const DiffsFoundError_1 = require("./errors/DiffsFoundError");
+const TestFailedError_1 = require("./errors/TestFailedError");
+const RunnerOptions_1 = require("./input/RunnerOptions");
+const TestResults_1 = require("./output/TestResults");
+const TestResultsSummary_1 = require("./output/TestResultsSummary");
+const utils = __importStar(require("@applitools/utils"));
+class EyesRunner {
+    constructor() {
+        this._eyes = [];
+    }
+    /** @internal */
+    attach(eyes, core) {
+        var _a;
+        (_a = this._core) !== null && _a !== void 0 ? _a : (this._core = core);
+        this._eyes.push(eyes);
+    }
+    /** @internal */
+    async openEyes(options) {
+        var _a;
+        (_a = this._manager) !== null && _a !== void 0 ? _a : (this._manager = await this._core.makeManager(this.config));
+        return await this._manager.openEyes(options);
+    }
+    async getAllTestResults(throwErr = true) {
+        var _a;
+        if (!this._manager)
+            return new TestResultsSummary_1.TestResultsSummaryData();
+        const [eyes] = this._eyes;
+        const deleteTest = (options) => this._core.deleteTest({
+            ...options,
+            settings: {
+                ...options.settings,
+                serverUrl: eyes.configuration.serverUrl,
+                apiKey: eyes.configuration.apiKey,
+                proxy: eyes.configuration.proxy,
+            },
+        });
+        try {
+            const summary = await this._manager.getResults({ settings: { throwErr } });
+            return new TestResultsSummary_1.TestResultsSummaryData({ summary, deleteTest });
+        }
+        catch (err) {
+            if ((_a = err.info) === null || _a === void 0 ? void 0 : _a.result) {
+                const result = new TestResults_1.TestResultsData({ result: err.info.result, deleteTest });
+                if (err.reason === 'test failed') {
+                    throw new TestFailedError_1.TestFailedError(err.message, result);
+                }
+                else if (err.reason === 'test different') {
+                    throw new DiffsFoundError_1.DiffsFoundError(err.message, result);
+                }
+                else if (err.reason === 'test new') {
+                    throw new NewTestError_1.NewTestError(err.message, result);
+                }
+            }
+            throw err;
+        }
+    }
+}
+exports.EyesRunner = EyesRunner;
+class VisualGridRunner extends EyesRunner {
+    constructor(optionsOrLegacyConcurrency) {
+        super();
+        if (utils.types.isNumber(optionsOrLegacyConcurrency)) {
+            this._legacyConcurrency = optionsOrLegacyConcurrency;
+        }
+        else if (optionsOrLegacyConcurrency) {
+            const options = optionsOrLegacyConcurrency instanceof RunnerOptions_1.RunnerOptionsFluent
+                ? optionsOrLegacyConcurrency.toJSON()
+                : optionsOrLegacyConcurrency;
+            this._testConcurrency = options.testConcurrency;
+        }
+    }
+    /** @internal */
+    get config() {
+        return {
+            type: 'ufg',
+            concurrency: this._testConcurrency,
+            legacyConcurrency: this._legacyConcurrency,
+        };
+    }
+    get testConcurrency() {
+        return this._testConcurrency;
+    }
+    /** @deprecated */
+    get legacyConcurrency() {
+        return this._legacyConcurrency;
+    }
+    /** @deprecated */
+    getConcurrentSessions() {
+        return this._legacyConcurrency;
+    }
+}
+exports.VisualGridRunner = VisualGridRunner;
+class ClassicRunner extends EyesRunner {
+    /** @internal */
+    get config() {
+        return { type: 'classic' };
+    }
+}
+exports.ClassicRunner = ClassicRunner;

package/dist/SDK.js

@@ -0,0 +1,41 @@
+"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.initSDK = void 0;
+const core_1 = require("@applitools/core");
+const utils = __importStar(require("@applitools/utils"));
+function initSDK(options) {
+    return {
+        core: getCoreWithCache(options),
+        spec: options === null || options === void 0 ? void 0 : options.spec,
+    };
+}
+exports.initSDK = initSDK;
+const getCoreWithCache = utils.general.cachify(getCore);
+function getCore({ makeCore = core_1.makeCore, ...options } = {}) {
+    var _a;
+    (_a = options.agentId) !== null && _a !== void 0 ? _a : (options.agentId = `js/eyes/${require('../package.json')}`);
+    return makeCore(options);
+}

package/dist/SessionEventHandlers.js

@@ -0,0 +1,193 @@
+"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.RemoteSessionEventHandler = exports.SessionEventHandlers = exports.SessionEventHandler = void 0;
+const utils = __importStar(require("@applitools/utils"));
+const RectangleSize_1 = require("./input/RectangleSize");
+const TestResults_1 = require("./output/TestResults");
+const ValidationInfo_1 = require("./output/ValidationInfo");
+const ValidationResult_1 = require("./output/ValidationResult");
+/** @deprecated */
+class SessionEventHandler {
+    /** @internal */
+    attach(eyes) {
+        this._detach = eyes.on((name, data = {}) => {
+            if (!utils.types.isFunction(this, name))
+                return;
+            const args = [];
+            if (name === 'setSizeWillStart') {
+                args.push(new RectangleSize_1.RectangleSizeData(data.viewportSize));
+            }
+            else if (['testStarted', 'validationWillStart', 'validationEnded', 'testEnded'].includes(name)) {
+                args.push(data.sessionId);
+                if (name === 'validationWillStart') {
+                    args.push(new ValidationInfo_1.ValidationInfoData(data.validationInfo));
+                }
+                else if (name === 'validationEnded') {
+                    args.push(data.validationId, new ValidationResult_1.ValidationResultData(data.validationResult));
+                }
+                else if (name === 'testEnded') {
+                    args.push(new TestResults_1.TestResultsData(data.testResults));
+                }
+            }
+            this[name](...args);
+        });
+    }
+    /** @internal */
+    detach() {
+        if (this._detach)
+            this._detach();
+    }
+}
+exports.SessionEventHandler = SessionEventHandler;
+/** @deprecated */
+class SessionEventHandlers extends SessionEventHandler {
+    constructor() {
+        super(...arguments);
+        this._handlers = new Set();
+    }
+    addEventHandler(handler) {
+        if (handler === this)
+            return;
+        this._handlers.add(handler);
+    }
+    removeEventHandler(handler) {
+        if (handler === this)
+            return;
+        this._handlers.delete(handler);
+    }
+    clearEventHandlers() {
+        this._handlers.clear();
+    }
+    initStarted() {
+        this._handlers.forEach(handler => handler.initStarted());
+    }
+    initEnded() {
+        this._handlers.forEach(handler => handler.initEnded());
+    }
+    setSizeWillStart(viewportSize) {
+        this._handlers.forEach(handler => handler.setSizeWillStart(viewportSize));
+    }
+    setSizeEnded() {
+        this._handlers.forEach(handler => handler.setSizeEnded());
+    }
+    testStarted(sessionId) {
+        this._handlers.forEach(handler => handler.testStarted(sessionId));
+    }
+    testEnded(sessionId, testResults) {
+        this._handlers.forEach(handler => handler.testEnded(sessionId, testResults));
+    }
+    validationWillStart(sessionId, validationInfo) {
+        this._handlers.forEach(handler => handler.validationWillStart(sessionId, validationInfo));
+    }
+    validationEnded(sessionId, validationId, validationResult) {
+        this._handlers.forEach(handler => handler.validationEnded(sessionId, validationId, validationResult));
+    }
+}
+exports.SessionEventHandlers = SessionEventHandlers;
+/**
+ * @undocumented
+ * @deprecated
+ */
+class RemoteSessionEventHandler extends SessionEventHandler {
+    constructor(optionsOrServerUrl, accessKey, timeout) {
+        super();
+        const options = utils.types.isObject(optionsOrServerUrl)
+            ? optionsOrServerUrl
+            : { serverUrl: optionsOrServerUrl, accessKey, timeout };
+        this._serverUrl = options.serverUrl;
+        this._accessKey = options.accessKey;
+        this._timeout = options.timeout;
+    }
+    get serverUrl() {
+        return this._serverUrl;
+    }
+    set serverUrl(serverUrl) {
+        this._serverUrl = serverUrl;
+    }
+    getServerUrl() {
+        return this._serverUrl;
+    }
+    setServerUrl(serverUrl) {
+        this.serverUrl = serverUrl;
+    }
+    get accessKey() {
+        return this._accessKey;
+    }
+    set accessKey(accessKey) {
+        this._accessKey = accessKey;
+    }
+    getAccessKey() {
+        return this.accessKey;
+    }
+    setAccessKey(accessKey) {
+        this._accessKey = accessKey;
+    }
+    get timeout() {
+        return this._timeout;
+    }
+    set timeout(timeout) {
+        this._timeout = timeout;
+    }
+    setTimeout(timeout) {
+        this._timeout = timeout;
+    }
+    getTimeout() {
+        return this._timeout;
+    }
+    initStarted() {
+        return undefined;
+    }
+    initEnded() {
+        return undefined;
+    }
+    setSizeWillStart() {
+        return undefined;
+    }
+    setSizeEnded() {
+        return undefined;
+    }
+    testStarted() {
+        return undefined;
+    }
+    testEnded() {
+        return undefined;
+    }
+    validationWillStart() {
+        return undefined;
+    }
+    validationEnded() {
+        return undefined;
+    }
+    /** @internal */
+    toJSON() {
+        return utils.general.toJSON(this, ['serverUrl', 'accessKey']);
+    }
+    /** @internal */
+    toString() {
+        return utils.general.toString(this);
+    }
+}
+exports.RemoteSessionEventHandler = RemoteSessionEventHandler;

package/dist/enums/AccessibilityGuidelinesVersion.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AccessibilityGuidelinesVersionEnum = void 0;
+var AccessibilityGuidelinesVersionEnum;
+(function (AccessibilityGuidelinesVersionEnum) {
+    AccessibilityGuidelinesVersionEnum["WCAG_2_0"] = "WCAG_2_0";
+    AccessibilityGuidelinesVersionEnum["WCAG_2_1"] = "WCAG_2_1";
+})(AccessibilityGuidelinesVersionEnum = exports.AccessibilityGuidelinesVersionEnum || (exports.AccessibilityGuidelinesVersionEnum = {}));

package/dist/enums/AccessibilityLevel.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AccessibilityLevelEnum = void 0;
+var AccessibilityLevelEnum;
+(function (AccessibilityLevelEnum) {
+    AccessibilityLevelEnum["AA"] = "AA";
+    AccessibilityLevelEnum["AAA"] = "AAA";
+})(AccessibilityLevelEnum = exports.AccessibilityLevelEnum || (exports.AccessibilityLevelEnum = {}));

package/dist/enums/AccessibilityRegionType.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AccessibilityRegionTypeEnum = void 0;
+var AccessibilityRegionTypeEnum;
+(function (AccessibilityRegionTypeEnum) {
+    AccessibilityRegionTypeEnum["IgnoreContrast"] = "IgnoreContrast";
+    AccessibilityRegionTypeEnum["RegularText"] = "RegularText";
+    AccessibilityRegionTypeEnum["LargeText"] = "LargeText";
+    AccessibilityRegionTypeEnum["BoldText"] = "BoldText";
+    AccessibilityRegionTypeEnum["GraphicalObject"] = "GraphicalObject";
+})(AccessibilityRegionTypeEnum = exports.AccessibilityRegionTypeEnum || (exports.AccessibilityRegionTypeEnum = {}));

package/dist/enums/AccessibilityStatus.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AccessibilityStatusEnum = void 0;
+var AccessibilityStatusEnum;
+(function (AccessibilityStatusEnum) {
+    AccessibilityStatusEnum["Passed"] = "Passed";
+    AccessibilityStatusEnum["Failed"] = "Failed";
+})(AccessibilityStatusEnum = exports.AccessibilityStatusEnum || (exports.AccessibilityStatusEnum = {}));

package/dist/enums/AndroidDeviceName.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AndroidDeviceNameEnum = void 0;
+var AndroidDeviceNameEnum;
+(function (AndroidDeviceNameEnum) {
+    AndroidDeviceNameEnum["Pixel_3_XL"] = "Pixel 3 XL";
+    AndroidDeviceNameEnum["Pixel_4"] = "Pixel 4";
+    AndroidDeviceNameEnum["Pixel_4_XL"] = "Pixel 4 XL";
+    AndroidDeviceNameEnum["Pixel_5"] = "Pixel 5";
+    AndroidDeviceNameEnum["Pixel_6"] = "Pixel 6";
+    AndroidDeviceNameEnum["Galaxy_S10"] = "Galaxy S10";
+    AndroidDeviceNameEnum["Galaxy_S10_Plus"] = "Galaxy S10 Plus";
+    AndroidDeviceNameEnum["Galaxy_Note_10"] = "Galaxy Note 10";
+    AndroidDeviceNameEnum["Galaxy_Note_10_Plus"] = "Galaxy Note 10 Plus";
+    AndroidDeviceNameEnum["Galaxy_S20"] = "Galaxy S20";
+    AndroidDeviceNameEnum["Galaxy_S20_Plus"] = "Galaxy S20 Plus";
+    AndroidDeviceNameEnum["Galaxy_S21"] = "Galaxy S21";
+    AndroidDeviceNameEnum["Galaxy_S21_Plus"] = "Galaxy S21 Plus";
+    AndroidDeviceNameEnum["Galaxy_S21_Ultra"] = "Galaxy S21 Ultra";
+    AndroidDeviceNameEnum["Galaxy_S22"] = "Galaxy S22";
+    AndroidDeviceNameEnum["Galaxy_S22_Plus"] = "Galaxy S22 Plus";
+    AndroidDeviceNameEnum["Galaxy_Tab_S7"] = "Galaxy Tab S7";
+    AndroidDeviceNameEnum["Galaxy_Tab_S8"] = "Galaxy Tab S8";
+    AndroidDeviceNameEnum["Xiaomi_Redmi_Note_10_JE"] = "Xiaomi Redmi Note 10 JE";
+    AndroidDeviceNameEnum["Xiaomi_Redmi_Note_11"] = "Xiaomi Redmi Note 11";
+    AndroidDeviceNameEnum["Xiaomi_Redmi_Note_11_Pro"] = "Xiaomi Redmi Note 11 Pro";
+    AndroidDeviceNameEnum["Sony_Xperia_1_II"] = "Sony Xperia 1 II";
+    AndroidDeviceNameEnum["Sony_Xperia_10_II"] = "Sony Xperia 10 II";
+    AndroidDeviceNameEnum["Sony_Xperia_Ace_II"] = "Sony Xperia Ace II";
+    AndroidDeviceNameEnum["Huawei_P30_Lite"] = "Huawei P30 Lite";
+})(AndroidDeviceNameEnum = exports.AndroidDeviceNameEnum || (exports.AndroidDeviceNameEnum = {}));

package/dist/enums/AndroidVersion.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AndroidVersionEnum = void 0;
+var AndroidVersionEnum;
+(function (AndroidVersionEnum) {
+    AndroidVersionEnum["LATEST"] = "latest";
+    AndroidVersionEnum["ONE_VERSION_BACK"] = "latest-1";
+})(AndroidVersionEnum = exports.AndroidVersionEnum || (exports.AndroidVersionEnum = {}));

package/dist/enums/BrowserType.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BrowserTypeEnum = void 0;
+var BrowserTypeEnum;
+(function (BrowserTypeEnum) {
+    BrowserTypeEnum["CHROME"] = "chrome";
+    BrowserTypeEnum["CHROME_ONE_VERSION_BACK"] = "chrome-one-version-back";
+    BrowserTypeEnum["CHROME_TWO_VERSIONS_BACK"] = "chrome-two-versions-back";
+    BrowserTypeEnum["FIREFOX"] = "firefox";
+    BrowserTypeEnum["FIREFOX_ONE_VERSION_BACK"] = "firefox-one-version-back";
+    BrowserTypeEnum["FIREFOX_TWO_VERSIONS_BACK"] = "firefox-two-versions-back";
+    BrowserTypeEnum["IE_11"] = "ie";
+    BrowserTypeEnum["IE_10"] = "ie10";
+    BrowserTypeEnum["EDGE"] = "edge";
+    BrowserTypeEnum["EDGE_CHROMIUM"] = "edgechromium";
+    BrowserTypeEnum["EDGE_LEGACY"] = "edgelegacy";
+    BrowserTypeEnum["EDGE_CHROMIUM_ONE_VERSION_BACK"] = "edgechromium-one-version-back";
+    BrowserTypeEnum["EDGE_CHROMIUM_TWO_VERSIONS_BACK"] = "edgechromium-two-versions-back";
+    BrowserTypeEnum["SAFARI"] = "safari";
+    BrowserTypeEnum["SAFARI_EARLY_ACCESS"] = "safari-earlyaccess";
+    BrowserTypeEnum["SAFARI_ONE_VERSION_BACK"] = "safari-one-version-back";
+    BrowserTypeEnum["SAFARI_TWO_VERSIONS_BACK"] = "safari-two-versions-back";
+})(BrowserTypeEnum = exports.BrowserTypeEnum || (exports.BrowserTypeEnum = {}));

package/dist/enums/CorsIframeHandle.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CorsIframeHandleEnum = void 0;
+/** @undocumented */
+var CorsIframeHandleEnum;
+(function (CorsIframeHandleEnum) {
+    CorsIframeHandleEnum["BLANK"] = "BLANK";
+    CorsIframeHandleEnum["KEEP"] = "KEEP";
+    CorsIframeHandleEnum["SNAPSHOT"] = "SNAPSHOT";
+})(CorsIframeHandleEnum = exports.CorsIframeHandleEnum || (exports.CorsIframeHandleEnum = {}));