@wdio/browserstack-service 8.45.0 → 8.47.0

package/build/cli/cliUtils.js

@@ -0,0 +1,430 @@
+import fs from 'node:fs';
+import fsp from 'node:fs/promises';
+import { platform, arch, homedir } from 'node:os';
+import path from 'node:path';
+import util, { promisify } from 'node:util';
+import { exec } from 'node:child_process';
+import yauzl from 'yauzl';
+import got from 'got';
+import { threadId } from 'node:worker_threads';
+import { createRequire } from 'node:module';
+const require = createRequire(import.meta.url);
+const { version: bstackServiceVersion } = require('../../package.json');
+import { isNullOrEmpty, nestedKeyValue, createDir, isWritable, setReadWriteAccess, isTrue, nodeRequest, getBrowserStackUser, getBrowserStackKey, isFalse, isTurboScale, shouldAddServiceVersion, } from '../util.js';
+import PerformanceTester from '../instrumentation/performance/performance-tester.js';
+import { EVENTS as PerformanceEvents } from '../instrumentation/performance/constants.js';
+import { BStackLogger as logger } from './cliLogger.js';
+import { UPDATED_CLI_ENDPOINT } from '../constants.js';
+import { TestFrameworkConstants } from './frameworks/constants/testFrameworkConstants.js';
+import APIUtils from './apiUtils.js';
+export class CLIUtils {
+    static automationFrameworkDetail = {};
+    static testFrameworkDetail = {};
+    static CLISupportedFrameworks = ['mocha'];
+    static isDevelopmentEnv() {
+        return process.env.BROWSERSTACK_CLI_ENV === 'development';
+    }
+    static getCLIParamsForDevEnv() {
+        return {
+            id: process.env.BROWSERSTACK_CLI_ENV || '',
+            listen: `unix:/tmp/sdk-platform-${process.env.BROWSERSTACK_CLI_ENV}.sock`
+        };
+    }
+    /**
+     * Build config object for binary session request
+     * @returns {string}
+     * @throws {Error}
+     */
+    static getBinConfig(config, capabilities, options, buildTag) {
+        const modifiedOpts = { ...options };
+        if (modifiedOpts.opts) {
+            modifiedOpts.browserStackLocalOptions = modifiedOpts.opts;
+            delete modifiedOpts.opts;
+        }
+        modifiedOpts.testContextOptions = {
+            skipSessionName: isFalse(modifiedOpts.setSessionName),
+            skipSessionStatus: isFalse(modifiedOpts.setSessionStatus),
+            sessionNameOmitTestTitle: modifiedOpts.sessionNameOmitTestTitle || false,
+            sessionNamePrependTopLevelSuiteTitle: modifiedOpts.sessionNamePrependTopLevelSuiteTitle || false,
+            sessionNameFormat: modifiedOpts.sessionNameFormat || ''
+        };
+        const commonBstackOptions = (() => {
+            const caps = config.capabilities;
+            if (caps &&
+                !Array.isArray(caps) &&
+                typeof caps === 'object' &&
+                'bstack:options' in caps) {
+                // Cast after guard to satisfy TypeScript
+                return caps['bstack:options'] || {};
+            }
+            return {};
+        })();
+        const isNonBstackA11y = isTurboScale(options) || !shouldAddServiceVersion(config, options.testObservability);
+        const observabilityOptions = options.testObservabilityOptions || {};
+        const binconfig = {
+            userName: observabilityOptions.user || config.user,
+            accessKey: observabilityOptions.key || config.key,
+            platforms: [],
+            isNonBstackA11yWDIO: isNonBstackA11y,
+            ...modifiedOpts,
+            ...commonBstackOptions,
+        };
+        binconfig.buildName = observabilityOptions.buildName || binconfig.buildName;
+        binconfig.projectName = observabilityOptions.projectName || binconfig.projectName;
+        binconfig.buildTag = this.getObservabilityBuildTags(observabilityOptions, buildTag) || [];
+        let caps = capabilities;
+        if (capabilities && !Array.isArray(capabilities)) {
+            caps = [capabilities];
+        }
+        if (Array.isArray(caps)) {
+            for (const cap of caps) {
+                const platform = {};
+                const capability = cap;
+                Object.keys(capability)
+                    .filter((key) => (key !== 'bstack:options'))
+                    .forEach((key) => {
+                    if (binconfig[key] === undefined) {
+                        platform[key] = capability[key];
+                    }
+                });
+                if (capability['bstack:options']) {
+                    Object.keys(capability['bstack:options'])
+                        .forEach((key) => {
+                        if (binconfig[key] === undefined) {
+                            platform[key] = capability['bstack:options'][key];
+                        }
+                    });
+                }
+                binconfig.platforms.push(platform);
+            }
+        }
+        return JSON.stringify(binconfig);
+    }
+    static getSdkVersion() {
+        return bstackServiceVersion;
+    }
+    static getSdkLanguage() {
+        return 'ECMAScript';
+    }
+    static async setupCliPath(config) {
+        logger.debug('Configuring Cli path.');
+        const developmentBinaryPath = process.env.SDK_CLI_BIN_PATH || null;
+        if (!isNullOrEmpty(developmentBinaryPath)) {
+            logger.debug(`Development Cli Path: ${developmentBinaryPath}`);
+            return developmentBinaryPath;
+        }
+        try {
+            const cliDir = this.getCliDir();
+            if (isNullOrEmpty(cliDir)) {
+                throw new Error('No writable directory available for the CLI');
+            }
+            const existingCliPath = this.getExistingCliPath(cliDir);
+            const finalBinaryPath = await this.checkAndUpdateCli(existingCliPath, cliDir, config);
+            logger.debug(`Resolved binary path: ${finalBinaryPath}`);
+            return finalBinaryPath;
+        }
+        catch (err) {
+            logger.debug(`Error in setting up cli path directory, Exception: ${util.format(err)}`);
+        }
+        return null;
+    }
+    static async checkAndUpdateCli(existingCliPath, cliDir, config) {
+        PerformanceTester.start(PerformanceEvents.SDK_CLI_CHECK_UPDATE);
+        logger.info(`Current CLI Path Found: ${existingCliPath}`);
+        const queryParams = {
+            sdk_version: CLIUtils.getSdkVersion(),
+            os: platform(),
+            os_arch: arch(),
+            cli_version: '0',
+            sdk_language: this.getSdkLanguage(),
+        };
+        if (!isNullOrEmpty(existingCliPath)) {
+            queryParams.cli_version = await this.runShellCommand(`${existingCliPath} version`);
+        }
+        const response = await this.requestToUpdateCLI(queryParams, config);
+        if (nestedKeyValue(response, ['updated_cli_version'])) {
+            logger.debug(`Need to update binary, current binary version: ${queryParams.cli_version}`);
+            const browserStackBinaryUrl = process.env.BROWSERSTACK_BINARY_URL || null;
+            if (!isNullOrEmpty(browserStackBinaryUrl)) {
+                logger.debug(`Using BROWSERSTACK_BINARY_URL: ${browserStackBinaryUrl}`);
+                response.url = browserStackBinaryUrl;
+            }
+            const finalBinaryPath = await this.downloadLatestBinary(nestedKeyValue(response, ['url']), cliDir);
+            PerformanceTester.end(PerformanceEvents.SDK_CLI_CHECK_UPDATE);
+            return finalBinaryPath;
+        }
+        PerformanceTester.end(PerformanceEvents.SDK_CLI_CHECK_UPDATE);
+        return existingCliPath;
+    }
+    static getCliDir() {
+        const writableDir = this.getWritableDir();
+        try {
+            if (isNullOrEmpty(writableDir)) {
+                throw new Error('No writable directory available for the CLI');
+            }
+            const cliDirPath = path.join(writableDir, 'cli');
+            if (!fs.existsSync(cliDirPath)) {
+                createDir(cliDirPath);
+            }
+            return cliDirPath;
+        }
+        catch (err) {
+            logger.error(`Error in getting writable directory, writableDir=${util.format(err)}`);
+            return '';
+        }
+    }
+    static getWritableDir() {
+        const writableDirOptions = [
+            process.env.BROWSERSTACK_FILES_DIR,
+            path.join(homedir(), '.browserstack'),
+            path.join('tmp', '.browserstack'),
+        ];
+        for (const path of writableDirOptions) {
+            if (isNullOrEmpty(path)) {
+                continue;
+            }
+            try {
+                if (fs.existsSync(path)) {
+                    logger.debug(`File ${path} already exist`);
+                    if (!isWritable(path)) {
+                        logger.debug(`Giving write permission to ${path}`);
+                        const success = setReadWriteAccess(path);
+                        if (!isTrue(success)) {
+                            logger.warn(`Unable to provide write permission to ${path}`);
+                        }
+                    }
+                }
+                else {
+                    logger.debug(`File does not exist: ${path}`);
+                    createDir(path);
+                    logger.debug(`Giving write permission to ${path}`);
+                    const success = setReadWriteAccess(path);
+                    if (!isTrue(success)) {
+                        logger.warn(`Unable to provide write permission to ${path}`);
+                    }
+                }
+                return path;
+            }
+            catch (err) {
+                logger.error(`Unable to get writable directory, exception ${util.format(err)}`);
+            }
+        }
+        return null;
+    }
+    static getExistingCliPath(cliDir) {
+        try {
+            // Check if the path exists and is a directory
+            if (!fs.existsSync(cliDir) || !fs.statSync(cliDir).isDirectory()) {
+                return '';
+            }
+            // List all files in the directory that start with "binary-"
+            const allBinaries = fs
+                .readdirSync(cliDir)
+                .map((file) => path.join(cliDir, file))
+                .filter((filePath) => fs.statSync(filePath).isFile() && path.basename(filePath).startsWith('binary-'));
+            if (allBinaries.length > 0) {
+                // Get the latest binary by comparing the last modified time
+                const latestBinary = allBinaries
+                    .map((filePath) => ({
+                    filePath,
+                    mtime: fs.statSync(filePath).mtime,
+                }))
+                    .reduce((latest, current) => {
+                    if (!latest || !latest.mtime) {
+                        return current;
+                    }
+                    if (current.mtime > latest.mtime) {
+                        return current;
+                    }
+                    return latest;
+                }, null);
+                return latestBinary ? latestBinary.filePath : '';
+            }
+            return ''; // No binary present
+        }
+        catch (err) {
+            logger.error(`Error while reading CLI path: ${util.format(err)}`);
+            return '';
+        }
+    }
+    static requestToUpdateCLI = async (queryParams, config) => {
+        const params = new URLSearchParams(queryParams);
+        const requestInit = {
+            headers: {
+                Authorization: `Basic ${Buffer.from(`${getBrowserStackUser(config)}:${getBrowserStackKey(config)}`).toString('base64')}`,
+            },
+        };
+        const response = await nodeRequest('GET', `${UPDATED_CLI_ENDPOINT}?${params.toString()}`, requestInit, APIUtils.BROWSERSTACK_AUTOMATE_API_URL);
+        logger.debug(`response ${JSON.stringify(response)}`);
+        return response;
+    };
+    static runShellCommand(cmdCommand, workingDir = '') {
+        return new Promise((resolve) => {
+            const process = exec(cmdCommand, { cwd: workingDir, timeout: 5000 }, (error, stdout, stderr) => {
+                if (error) {
+                    resolve(stderr.trim() || 'SHELL_EXECUTE_ERROR');
+                }
+                else {
+                    resolve(stdout.trim());
+                }
+            });
+            // Ensure the process is killed if it exceeds the timeout
+            process.on('error', () => {
+                resolve('SHELL_EXECUTE_ERROR');
+            });
+        });
+    }
+    static downloadLatestBinary = async (binDownloadUrl, cliDir) => {
+        PerformanceTester.start(PerformanceEvents.SDK_CLI_DOWNLOAD);
+        logger.debug(`Downloading SDK binary from: ${binDownloadUrl}`);
+        try {
+            const zipFilePath = path.join(cliDir, 'downloaded_file.zip');
+            const downloadedFileStream = fs.createWriteStream(zipFilePath);
+            return new Promise((resolve, reject) => {
+                const binaryName = null;
+                const stream = got.stream(binDownloadUrl, {
+                    followRedirect: true
+                });
+                stream.pipe(downloadedFileStream);
+                downloadedFileStream.on('error', function (err) {
+                    logger.error('Got Error while downloading percy binary file' + err);
+                    PerformanceTester.end(PerformanceEvents.SDK_CLI_DOWNLOAD, false, util.format(err));
+                    reject(err);
+                });
+                stream.on('error', (err) => {
+                    logger.error(`Got Error in cli binary downloading request ${util.format(err)}`);
+                    PerformanceTester.end(PerformanceEvents.SDK_CLI_DOWNLOAD, false, util.format(err));
+                    reject(err);
+                });
+                CLIUtils.downloadFileStream(downloadedFileStream, binaryName, zipFilePath, cliDir, resolve, reject);
+                PerformanceTester.end(PerformanceEvents.SDK_CLI_DOWNLOAD);
+            });
+        }
+        catch (err) {
+            PerformanceTester.end(PerformanceEvents.SDK_CLI_DOWNLOAD, false, util.format(err));
+            logger.debug(`Failed to download binary, Exception: ${util.format(err)}`);
+            return null;
+        }
+    };
+    static downloadFileStream(downloadedFileStream, binaryName, zipFilePath, cliDir, resolve, reject) {
+        downloadedFileStream.on('close', async function () {
+            const yauzlOpenPromise = promisify(yauzl.open);
+            try {
+                const zipfile = await yauzlOpenPromise(zipFilePath, { lazyEntries: true });
+                zipfile.readEntry();
+                zipfile.on('entry', async (entry) => {
+                    if (!binaryName) {
+                        binaryName = entry.fileName;
+                    }
+                    if (/\/$/.test(entry.fileName)) {
+                        // Directory file names end with '/'.
+                        zipfile.readEntry();
+                    }
+                    else {
+                        // file entry
+                        const writeStream = fs.createWriteStream(path.join(cliDir, entry.fileName));
+                        const openReadStreamPromise = promisify(zipfile.openReadStream).bind(zipfile);
+                        try {
+                            const readStream = await openReadStreamPromise(entry);
+                            readStream.on('end', function () {
+                                writeStream.close();
+                                zipfile.readEntry();
+                            });
+                            readStream.pipe(writeStream);
+                        }
+                        catch (zipErr) {
+                            reject(zipErr);
+                        }
+                        if (entry.fileName === binaryName) {
+                            zipfile.close();
+                        }
+                    }
+                });
+                zipfile.on('error', (zipErr) => {
+                    reject(zipErr);
+                });
+                zipfile.once('end', () => {
+                    fsp.unlink(zipFilePath)
+                        .catch(() => {
+                        logger.warn(`Failed to delete zip file: ${zipFilePath}`);
+                    });
+                    fsp.chmod(`${cliDir}/${binaryName}`, '0755')
+                        .then(() => {
+                        resolve(`${cliDir}/${binaryName}`);
+                    }).catch((err) => {
+                        reject(err);
+                    });
+                    zipfile.close();
+                });
+            }
+            catch (err) {
+                reject(err);
+            }
+        });
+    }
+    static getTestFrameworkDetail() {
+        if (process.env.BROWSERSTACK_TEST_FRAMEWORK_DETAIL) {
+            return JSON.parse(process.env.BROWSERSTACK_TEST_FRAMEWORK_DETAIL);
+        }
+        return this.testFrameworkDetail;
+    }
+    static getAutomationFrameworkDetail() {
+        if (process.env.BROWSERSTACK_AUTOMATION_FRAMEWORK_DETAIL) {
+            return JSON.parse(process.env.BROWSERSTACK_AUTOMATION_FRAMEWORK_DETAIL);
+        }
+        return this.automationFrameworkDetail;
+    }
+    static setFrameworkDetail(testFramework, automationFramework) {
+        if (!testFramework || !automationFramework) {
+            logger.debug(`Test or Automation framework not provided testFramework=${testFramework}, automationFramework=${automationFramework}`);
+        }
+        this.testFrameworkDetail = {
+            name: testFramework,
+            version: { [testFramework]: CLIUtils.getSdkVersion() },
+        };
+        this.automationFrameworkDetail = {
+            name: automationFramework,
+            version: { [automationFramework]: CLIUtils.getSdkVersion() },
+        };
+        process.env.BROWSERSTACK_AUTOMATION_FRAMEWORK_DETAIL = JSON.stringify(this.automationFrameworkDetail);
+        process.env.BROWSERSTACK_TEST_FRAMEWORK_DETAIL = JSON.stringify(this.testFrameworkDetail);
+    }
+    /**
+     * Get the current instance name using thread id and processId
+     * @returns {string}
+     */
+    static getCurrentInstanceName() {
+        return `${process.pid}:${threadId}`;
+    }
+    /**
+     *
+     * @param {TestFrameworkState | AutomationFrameworkState} frameworkState
+     * @param {HookState} hookState
+     * @returns {string}
+     */
+    static getHookRegistryKey(frameworkState, hookState) {
+        return `${frameworkState}:${hookState}`;
+    }
+    static matchHookRegex(hookState) {
+        const pattern = new RegExp(TestFrameworkConstants.HOOK_REGEX);
+        return pattern.test(hookState);
+    }
+    static getObservabilityBuildTags(observabilityOptions, bstackBuildTag) {
+        if (process.env.TEST_OBSERVABILITY_BUILD_TAG) {
+            return process.env.TEST_OBSERVABILITY_BUILD_TAG.split(',');
+        }
+        if (observabilityOptions.buildTag) {
+            return observabilityOptions.buildTag;
+        }
+        if (bstackBuildTag) {
+            return [bstackBuildTag];
+        }
+        return [];
+    }
+    static checkCLISupportedFrameworks(framework) {
+        if (framework === undefined) {
+            return false;
+        }
+        return this.CLISupportedFrameworks.includes(framework);
+    }
+}

package/build/cli/eventDispatcher.d.ts

@@ -0,0 +1,28 @@
+/**
+ * EventDispatcher - Singleton class for event handling
+ */
+declare class EventDispatcher {
+    #private;
+    observers: Record<string, Function[]>;
+    constructor();
+    /**
+   * Get the EventDispatcher singleton instance
+   * @returns {EventDispatcher} The singleton instance
+   */
+    static getInstance(): EventDispatcher;
+    /**
+   * Add event observer
+   * @param {string} event - Event name
+   * @param {Function} callback - Callback function
+   */
+    registerObserver(hookRegistryKey: string, callback: Function): void;
+    /**
+   * Notify registered observers on an event
+   * @param {string} event - Event name
+   * @param {*} data - Event data
+   */
+    notifyObserver(event: string, args: unknown): Promise<void>;
+}
+export declare const eventDispatcher: EventDispatcher;
+export {};
+//# sourceMappingURL=eventDispatcher.d.ts.map

package/build/cli/eventDispatcher.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"eventDispatcher.d.ts","sourceRoot":"","sources":["../../src/cli/eventDispatcher.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,cAAM,eAAe;;IAGjB,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,QAAQ,EAAE,CAAC,CAAA;;IAMrC;;;KAGC;IACD,MAAM,CAAC,WAAW;IAOlB;;;;KAIC;IACD,gBAAgB,CAAC,eAAe,EAAE,MAAM,EAAE,QAAQ,EAAE,QAAQ;IAQ5D;;;;KAIC;IACK,cAAc,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO;CAQpD;AAGD,eAAO,MAAM,eAAe,iBAAgC,CAAA"}

package/build/cli/eventDispatcher.js

@@ -0,0 +1,48 @@
+/**
+ * EventDispatcher - Singleton class for event handling
+ */
+class EventDispatcher {
+    static #instance = null;
+    observers;
+    constructor() {
+        this.observers = {};
+    }
+    /**
+   * Get the EventDispatcher singleton instance
+   * @returns {EventDispatcher} The singleton instance
+   */
+    static getInstance() {
+        if (!EventDispatcher.#instance) {
+            EventDispatcher.#instance = new EventDispatcher();
+        }
+        return EventDispatcher.#instance;
+    }
+    /**
+   * Add event observer
+   * @param {string} event - Event name
+   * @param {Function} callback - Callback function
+   */
+    registerObserver(hookRegistryKey, callback) {
+        if (!this.observers[hookRegistryKey]) {
+            this.observers[hookRegistryKey] = [];
+        }
+        this.observers[hookRegistryKey].push(callback);
+    }
+    /**
+   * Notify registered observers on an event
+   * @param {string} event - Event name
+   * @param {*} data - Event data
+   */
+    async notifyObserver(event, args) {
+        if (this.observers[event]) {
+            for (const callback of this.observers[event]) {
+                await callback(args);
+            }
+            return;
+        }
+    }
+}
+// Create the singleton instance
+export const eventDispatcher = EventDispatcher.getInstance();
+// Object.freeze to prevent modification of the instance
+Object.freeze(eventDispatcher);

package/build/cli/frameworks/automationFramework.d.ts

@@ -0,0 +1,89 @@
+import type AutomationFrameworkInstance from '../instances/automationFrameworkInstance.js';
+import type TrackedContext from '../instances/trackedContext.js';
+/**
+ * AutomationFramework - Automation Framework abstract class
+ */
+export default class AutomationFramework {
+    #private;
+    static instances: Map<any, any>;
+    static KEY_AUTOMATION_SESSIONS: string;
+    static KEY_NON_BROWSERSTACK_AUTOMATION_SESSIONS: string;
+    /**
+   * Constructor for the AutomationFramework
+   * @param {string} automationFrameworkName - Name of the automation framework
+   * @param {string} automationFrameworkVersion - Version of the automation framework
+  */
+    constructor(automationFrameworkName: string, automationFrameworkVersion: string);
+    /**
+   * Get the automation framework name
+   * @returns {string} The name of the automation framework
+   */
+    getAutomationFrameworkName(): string;
+    /**
+   * Get the automation framework version
+   * @returns {string} The version of the automation framework
+   */
+    getAutomationFrameworkVersion(): string;
+    /**
+   * Track an event
+   * @param {Object}
+   * @param {Object}
+   * @param {Object}
+   * @returns {void}
+   */
+    trackEvent(automationFrameworkState: State, hookState: State, args?: unknown): Promise<void>;
+    /**
+   *
+   * @param {*} instance
+   * @param {*} automationFrameworkState
+   * @param {*} hookState
+   * @param {*} args
+   */
+    runHooks(instance: AutomationFrameworkInstance, automationFrameworkState: State, hookState: State, args?: unknown): Promise<void>;
+    /**
+   * Register an observer
+   * @returns {void}
+   */
+    static registerObserver(automationFrameworkState: State, hookState: State, callback: Function): void;
+    /**
+   * Set the tracked instance
+   * @param {TrackedInstance} context - The context
+   * @param {TrackedInstance} instance - The instance
+   * @returns {void}
+   */
+    static setTrackedInstance(context: TrackedContext, instance: AutomationFrameworkInstance): void;
+    /**
+   * Get the tracked instance
+   * @returns {TrackedInstance} The tracked instance
+   */
+    static getTrackedInstance(): any;
+    /**
+   * Set the state
+   * @param {TrackedInstance} instance - The instance
+   * @param {string} key - The key
+   * @param {*} value - The value
+   * @returns
+   */
+    static setState(instance: AutomationFrameworkInstance, key: string, value: unknown): void;
+    /**
+   * Get the state
+   * @param {TrackedInstance} instance - The instance
+   * @param {string} key - The key
+   * @returns {*} The state
+   */
+    static getState(instance: AutomationFrameworkInstance, key: string): any;
+    static isAutomationSession(instance: AutomationFrameworkInstance): boolean;
+    /**
+     * Set the driver for the automation framework instance
+     * @param {AutomationFrameworkInstance} instance - The automation framework instance
+     * @param {*} driver - The driver object
+     */
+    static setDriver(instance: AutomationFrameworkInstance, driver: unknown): void;
+    /**
+     * Get the driver from the automation framework instance
+     * @param {AutomationFrameworkInstance} instance - The automation framework instance
+     * @returns {*} The driver object or null
+     */
+    static getDriver(instance: AutomationFrameworkInstance): unknown;
+}
+//# sourceMappingURL=automationFramework.d.ts.map

package/build/cli/frameworks/automationFramework.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"automationFramework.d.ts","sourceRoot":"","sources":["../../../src/cli/frameworks/automationFramework.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,2BAA2B,MAAM,6CAA6C,CAAA;AAC1F,OAAO,KAAK,cAAc,MAAM,gCAAgC,CAAA;AAGhE;;GAEG;AACH,MAAM,CAAC,OAAO,OAAO,mBAAmB;;IAIpC,MAAM,CAAC,SAAS,gBAAY;IAC5B,MAAM,CAAC,uBAAuB,SAAwB;IACtD,MAAM,CAAC,wCAAwC,SAAyC;IAExF;;;;IAIA;gBACY,uBAAuB,EAAE,MAAM,EAAE,0BAA0B,EAAE,MAAM;IAK/E;;;KAGC;IACD,0BAA0B;IAI1B;;;KAGC;IACD,6BAA6B;IAI7B;;;;;;KAMC;IACK,UAAU,CAAC,wBAAwB,EAAE,KAAK,EAAE,SAAS,EAAE,KAAK,EAAE,IAAI,GAAE,OAAY;IAItF;;;;;;KAMC;IACK,QAAQ,CAAC,QAAQ,EAAE,2BAA2B,EAAE,wBAAwB,EAAE,KAAK,EAAE,SAAS,EAAE,KAAK,EAAE,IAAI,GAAE,OAAY;IAO3H;;;KAGC;IACD,MAAM,CAAC,gBAAgB,CAAC,wBAAwB,EAAE,KAAK,EAAE,SAAS,EAAE,KAAK,EAAE,QAAQ,EAAE,QAAQ;IAI7F;;;;;KAKC;IACD,MAAM,CAAC,kBAAkB,CAAC,OAAO,EAAE,cAAc,EAAE,QAAQ,EAAE,2BAA2B;IAKxF;;;KAGC;IACD,MAAM,CAAC,kBAAkB;IAMzB;;;;;;KAMC;IACD,MAAM,CAAC,QAAQ,CAAC,QAAQ,EAAE,2BAA2B,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO;IAIlF;;;;;KAKC;IACD,MAAM,CAAC,QAAQ,CAAC,QAAQ,EAAE,2BAA2B,EAAE,GAAG,EAAE,MAAM;IAIlE,MAAM,CAAC,mBAAmB,CAAC,QAAQ,EAAE,2BAA2B,GAAG,OAAO;IAI1E;;;;OAIG;IACH,MAAM,CAAC,SAAS,CAAC,QAAQ,EAAE,2BAA2B,EAAE,MAAM,EAAE,OAAO,GAAG,IAAI;IAQ9E;;;;OAIG;IACH,MAAM,CAAC,SAAS,CAAC,QAAQ,EAAE,2BAA2B,GAAG,OAAO;CAKnE"}